use of com.mysql.cj.jdbc.MysqlPooledConnection in project JavaSegundasQuintas by ecteruel.
the class ConnectionRegressionTest method testBug62452.
/**
* Tests fix for BUG#62452 - NPE thrown in JDBC4MySQLPooledException when statement is closed.
*
* @throws Exception
*/
@Test
public void testBug62452() throws Exception {
PooledConnection con = null;
MysqlConnectionPoolDataSource pds = new MysqlConnectionPoolDataSource();
pds.setUrl(dbUrl);
pds.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
pds.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
con = pds.getPooledConnection();
assertTrue(con instanceof MysqlPooledConnection);
testBug62452WithConnection(con);
MysqlXADataSource xads = new MysqlXADataSource();
xads.setUrl(dbUrl);
xads.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
xads.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(false);
con = xads.getXAConnection();
assertTrue(con instanceof MysqlXAConnection);
testBug62452WithConnection(con);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(true);
con = xads.getXAConnection();
assertTrue(con instanceof SuspendableXAConnection);
testBug62452WithConnection(con);
}
use of com.mysql.cj.jdbc.MysqlPooledConnection in project ABC by RuiPinto96274.
the class ConnectionRegressionTest method testBug62452.
/**
* Tests fix for BUG#62452 - NPE thrown in JDBC4MySQLPooledException when statement is closed.
*
* @throws Exception
*/
@Test
public void testBug62452() throws Exception {
PooledConnection con = null;
MysqlConnectionPoolDataSource pds = new MysqlConnectionPoolDataSource();
pds.setUrl(dbUrl);
pds.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
pds.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
con = pds.getPooledConnection();
assertTrue(con instanceof MysqlPooledConnection);
testBug62452WithConnection(con);
MysqlXADataSource xads = new MysqlXADataSource();
xads.setUrl(dbUrl);
xads.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
xads.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(false);
con = xads.getXAConnection();
assertTrue(con instanceof MysqlXAConnection);
testBug62452WithConnection(con);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(true);
con = xads.getXAConnection();
assertTrue(con instanceof SuspendableXAConnection);
testBug62452WithConnection(con);
}
use of com.mysql.cj.jdbc.MysqlPooledConnection in project aws-mysql-jdbc by awslabs.
the class ConnectionRegressionTest method testBug62452.
/**
* Tests fix for BUG#62452 - NPE thrown in JDBC4MySQLPooledException when statement is closed.
*
* @throws Exception
*/
@Test
public void testBug62452() throws Exception {
PooledConnection con = null;
MysqlConnectionPoolDataSource pds = new MysqlConnectionPoolDataSource();
pds.setUrl(dbUrl);
pds.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
pds.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
con = pds.getPooledConnection();
assertTrue(con instanceof MysqlPooledConnection);
testBug62452WithConnection(con);
MysqlXADataSource xads = new MysqlXADataSource();
xads.setUrl(dbUrl);
xads.getStringProperty(PropertyKey.sslMode.getKeyName()).setValue("DISABLED");
xads.getBooleanProperty(PropertyKey.allowPublicKeyRetrieval.getKeyName()).setValue(true);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(false);
con = xads.getXAConnection();
assertTrue(con instanceof MysqlXAConnection);
testBug62452WithConnection(con);
xads.getProperty(PropertyKey.pinGlobalTxToPhysicalConnection).setValue(true);
con = xads.getXAConnection();
assertTrue(con instanceof SuspendableXAConnection);
testBug62452WithConnection(con);
}
use of com.mysql.cj.jdbc.MysqlPooledConnection in project aws-mysql-jdbc by awslabs.
the class CallableStatementTest method testClosedWrapper.
@SuppressWarnings("deprecation")
@Test
public void testClosedWrapper() throws Exception {
String sql = "SELECT 1";
int autoGeneratedKeys = 0;
int[] columnIndexes = new int[] { 0 };
String[] columnNames = new String[] { "f1" };
int parameterIndex = 1;
String parameterName = "p1";
Calendar cal = new GregorianCalendar();
Map<String, Class<?>> typeMap = new HashMap<>();
typeMap.put("1", String.class);
int scale = 3;
String typeName = String.class.getName();
InputStream istr = new InputStream() {
@Override
public int read() throws IOException {
return 0;
}
};
Reader reader = new StringReader(sql);
MysqlPooledConnection con = new MysqlPooledConnection((JdbcConnection) this.conn);
CallableStatementWrapper w = new CallableStatementWrapper(new ConnectionWrapper(con, (JdbcConnection) this.conn, false), con, null);
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.addBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.addBatch(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.cancel();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearParameters();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearWarnings();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.closeOnCompletion();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.enableStreamingResults();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute("SELECT 1");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeQuery();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeQuery(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getArray(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getArray(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterIndex, 10);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBlob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBlob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBoolean(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBoolean(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getByte(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getByte(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBytes(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getCharacterStream(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getCharacterStream(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getClob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getClob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDouble(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDouble(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFloat(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFloat(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getInt(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getInt(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLong(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLong(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNCharacterStream(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNCharacterStream(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNClob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNClob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNString(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNString(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex, String.class);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName, String.class);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex, typeMap);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName, typeMap);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getParameterMetaData();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getQueryTimeout();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRef(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRef(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSet();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetConcurrency();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetHoldability();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetType();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRowId(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRowId(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getShort(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getShort(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getSQLXML(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getSQLXML(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getString(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getString(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getUpdateCount();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getURL(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getURL(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getWarnings();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getConnection();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFetchDirection();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFetchSize();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getGeneratedKeys();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLargeMaxRows();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLargeUpdateCount();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMaxFieldSize();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMaxRows();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMetaData();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMoreResults();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMoreResults(0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isClosed();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isCloseOnCompletion();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isPoolable();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setArray(parameterIndex, (java.sql.Array) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBigDecimal(parameterIndex, BigDecimal.valueOf(1L));
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBigDecimal(parameterName, BigDecimal.valueOf(1L));
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, (Blob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, (Blob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBoolean(parameterIndex, true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBoolean(parameterName, true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setByte(parameterIndex, (byte) 0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setByte(parameterName, (byte) 0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBytes(parameterIndex, (byte[]) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBytes(parameterName, (byte[]) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, (Clob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, (Clob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCursorName("qqq");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterIndex, (Date) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterName, (Date) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterIndex, (Date) null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterName, (Date) null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDouble(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDouble(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setEscapeProcessing(true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFetchDirection(ResultSet.FETCH_FORWARD);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFetchSize(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFloat(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFloat(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setInt(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setInt(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLargeMaxRows(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLong(parameterIndex, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLong(parameterName, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setMaxFieldSize(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setMaxRows(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, (NClob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, (NClob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNString(parameterIndex, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNString(parameterName, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterIndex, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterName, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterIndex, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterName, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, Types.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, MysqlType.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, Types.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, MysqlType.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setPoolable(true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setQueryTimeout(5);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRef(parameterIndex, (Ref) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRowId(parameterIndex, (RowId) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRowId(parameterName, (RowId) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setShort(parameterIndex, (short) 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setShort(parameterName, (short) 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setSQLXML(parameterIndex, (SQLXML) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setSQLXML(parameterName, (SQLXML) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setString(parameterIndex, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setString(parameterName, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterIndex, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterName, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterIndex, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterName, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setUnicodeStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setURL(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setURL(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.wasNull();
return null;
}
});
w.close();
}
use of com.mysql.cj.jdbc.MysqlPooledConnection in project JavaSegundasQuintas by ecteruel.
the class CallableStatementTest method testClosedWrapper.
@SuppressWarnings("deprecation")
@Test
public void testClosedWrapper() throws Exception {
String sql = "SELECT 1";
int autoGeneratedKeys = 0;
int[] columnIndexes = new int[] { 0 };
String[] columnNames = new String[] { "f1" };
int parameterIndex = 1;
String parameterName = "p1";
Calendar cal = new GregorianCalendar();
Map<String, Class<?>> typeMap = new HashMap<>();
typeMap.put("1", String.class);
int scale = 3;
String typeName = String.class.getName();
InputStream istr = new InputStream() {
@Override
public int read() throws IOException {
return 0;
}
};
Reader reader = new StringReader(sql);
MysqlPooledConnection con = new MysqlPooledConnection((JdbcConnection) this.conn);
CallableStatementWrapper w = new CallableStatementWrapper(new ConnectionWrapper(con, (JdbcConnection) this.conn, false), con, null);
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.addBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.addBatch(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.cancel();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearParameters();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.clearWarnings();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.closeOnCompletion();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.enableStreamingResults();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute("SELECT 1");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.execute(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeBatch();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeLargeUpdate(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeQuery();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeQuery(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, autoGeneratedKeys);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, columnIndexes);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.executeUpdate(sql, columnNames);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getArray(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getArray(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBigDecimal(parameterIndex, 10);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBlob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBlob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBoolean(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBoolean(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getByte(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getByte(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getBytes(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getCharacterStream(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getCharacterStream(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getClob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getClob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDate(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDouble(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getDouble(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFloat(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFloat(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getInt(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getInt(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLong(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLong(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNCharacterStream(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNCharacterStream(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNClob(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNClob(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNString(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getNString(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex, String.class);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName, String.class);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterIndex, typeMap);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getObject(parameterName, typeMap);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getParameterMetaData();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getQueryTimeout();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRef(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRef(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSet();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetConcurrency();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetHoldability();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getResultSetType();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRowId(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getRowId(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getShort(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getShort(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getSQLXML(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getSQLXML(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getString(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getString(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTime(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterIndex, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getTimestamp(parameterName, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getUpdateCount();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getURL(parameterIndex);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getURL(parameterName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getWarnings();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getConnection();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFetchDirection();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getFetchSize();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getGeneratedKeys();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLargeMaxRows();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getLargeUpdateCount();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMaxFieldSize();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMaxRows();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMetaData();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMoreResults();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.getMoreResults(0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isClosed();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isCloseOnCompletion();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.isPoolable();
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterIndex, MysqlType.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR, scale);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.registerOutParameter(parameterName, MysqlType.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setArray(parameterIndex, (java.sql.Array) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setAsciiStream(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBigDecimal(parameterIndex, BigDecimal.valueOf(1L));
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBigDecimal(parameterName, BigDecimal.valueOf(1L));
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBinaryStream(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, (Blob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, (Blob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, istr);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterIndex, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBlob(parameterName, istr, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBoolean(parameterIndex, true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBoolean(parameterName, true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setByte(parameterIndex, (byte) 0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setByte(parameterName, (byte) 0);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBytes(parameterIndex, (byte[]) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setBytes(parameterName, (byte[]) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCharacterStream(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, (Clob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, (Clob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setClob(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setCursorName("qqq");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterIndex, (Date) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterName, (Date) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterIndex, (Date) null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDate(parameterName, (Date) null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDouble(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setDouble(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setEscapeProcessing(true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFetchDirection(ResultSet.FETCH_FORWARD);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFetchSize(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFloat(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setFloat(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setInt(parameterIndex, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setInt(parameterName, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLargeMaxRows(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLong(parameterIndex, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setLong(parameterName, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setMaxFieldSize(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setMaxRows(1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNCharacterStream(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, (NClob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, (NClob) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, reader);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterIndex, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNClob(parameterName, reader, 1L);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNString(parameterIndex, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNString(parameterName, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterIndex, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterName, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterIndex, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setNull(parameterName, Types.VARCHAR, typeName);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, Types.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, MysqlType.VARCHAR);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, Types.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterIndex, (Object) null, MysqlType.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, Types.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setObject(parameterName, (Object) null, MysqlType.VARCHAR, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setPoolable(true);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setQueryTimeout(5);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRef(parameterIndex, (Ref) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRowId(parameterIndex, (RowId) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setRowId(parameterName, (RowId) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setShort(parameterIndex, (short) 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setShort(parameterName, (short) 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setSQLXML(parameterIndex, (SQLXML) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setSQLXML(parameterName, (SQLXML) null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setString(parameterIndex, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setString(parameterName, "");
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterIndex, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTime(parameterName, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterIndex, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setTimestamp(parameterName, null, cal);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setUnicodeStream(parameterIndex, istr, 1);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setURL(parameterIndex, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.setURL(parameterName, null);
return null;
}
});
assertThrows(SQLException.class, "No operations allowed after statement closed.", new Callable<Void>() {
public Void call() throws Exception {
w.wasNull();
return null;
}
});
w.close();
}
Aggregations