Examples with ConnectionProxy com.alibaba.druid.proxy.jdbc.ConnectionProxy used on opensource projects

Example 21 with ConnectionProxy

use of com.alibaba.druid.proxy.jdbc.ConnectionProxy in project druid by alibaba.

the class StatFilter method internalBeforeStatementExecute.

private final void internalBeforeStatementExecute(StatementProxy statement, String sql) {
    JdbcDataSourceStat dataSourceStat = statement.getConnectionProxy().getDirectDataSource().getDataSourceStat();
    dataSourceStat.getStatementStat().beforeExecute();
    final ConnectionProxy connection = statement.getConnectionProxy();
    final JdbcConnectionStat.Entry connectionCounter = getConnectionInfo(connection);
    statement.setLastExecuteStartNano();
    connectionCounter.setLastSql(sql);
    if (connectionStackTraceEnable) {
        connectionCounter.setLastStatementStatckTrace(new Exception());
    }
    // //////////SQL
    JdbcSqlStat sqlStat = statement.getSqlStat();
    if (sqlStat == null || sqlStat.isRemoved()) {
        sqlStat = createSqlStat(statement, sql);
        statement.setSqlStat(sqlStat);
    }
    JdbcStatContext statContext = JdbcStatManager.getInstance().getStatContext();
    if (statContext != null) {
        sqlStat.setName(statContext.getName());
        sqlStat.setFile(statContext.getFile());
    }
    boolean inTransaction = false;
    try {
        inTransaction = !statement.getConnectionProxy().getAutoCommit();
    } catch (SQLException e) {
        LOG.error("getAutoCommit error", e);
    }
    if (sqlStat != null) {
        sqlStat.setExecuteLastStartTime(System.currentTimeMillis());
        sqlStat.incrementRunningCount();
        if (inTransaction) {
            sqlStat.incrementInTransactionCount();
        }
    }
    StatFilterContext.getInstance().executeBefore(sql, inTransaction);
    Profiler.enter(sql, Profiler.PROFILE_TYPE_SQL);
}

Example 22 with ConnectionProxy

use of com.alibaba.druid.proxy.jdbc.ConnectionProxy in project druid by alibaba.

the class DruidConnectionHolderTest2 method setUp.

protected void setUp() throws Exception {
    dataSource = new DruidDataSource();
    dataSource.setUrl("jdbc:mock:xxx");
    dataSource.setTestOnBorrow(false);
    dataSource.setPoolPreparedStatements(true);
    dataSource.getProxyFilters().add(new FilterAdapter() {

        public int connection_getTransactionIsolation(FilterChain chain, ConnectionProxy connection) throws SQLException {
            throw new SQLException();
        }
    });
}

Example 23 with ConnectionProxy

use of com.alibaba.druid.proxy.jdbc.ConnectionProxy in project druid by alibaba.

the class HoldableUnsupportTest method setUp.

protected void setUp() throws Exception {
    dataSource = new DruidDataSource();
    dataSource.setUrl("jdbc:mock:xxx");
    Filter filter = new FilterAdapter() {

        @Override
        public int connection_getHoldability(FilterChain chain, ConnectionProxy connection) throws SQLException {
            throw new UnsupportedOperationException();
        }
    };
    dataSource.getProxyFilters().add(filter);
}

Example 24 with ConnectionProxy

use of com.alibaba.druid.proxy.jdbc.ConnectionProxy in project druid by alibaba.

the class DriverTest method test_driver.

public void test_driver() throws Exception {
    String url_0 = "jdbc:wrap-jdbc:filters=default:name=driverTest:jdbc:derby:memory:driverTestDB;create=true";
    String url_1 = "jdbc:wrap-jdbc:filters=counter:name=driverTest:jdbc:derby:memory:driverTestDB;create=true";
    String url_2 = "jdbc:wrap-jdbc:filters=log4j:name=driverTest:jdbc:derby:memory:driverTestDB;create=true";
    String url_3 = "jdbc:wrap-jdbc:filters=commonLogging:name=driverTest:jdbc:derby:memory:driverTestDB;create=true";
    String url_4 = "jdbc:wrap-jdbc:driver=org.apache.derby.jdbc.EmbeddedDriver:filters=commonLogging:name=driverTest:jdbc:derby:memory:driverTestDB;create=true";
    Class.forName("com.alibaba.druid.proxy.DruidDriver");
    Connection connection = DriverManager.getConnection(url_0);
    connection.close();
    Driver driver = DriverManager.getDriver(url_0);
    DruidDriver driverWrapper = (DruidDriver) driver;
    Assert.assertEquals(4, driverWrapper.getMajorVersion());
    Assert.assertEquals(0, driverWrapper.getMinorVersion());
    Assert.assertEquals(true, driverWrapper.jdbcCompliant());
    Assert.assertTrue(driverWrapper.getConnectCount() > 0);
    Assert.assertNotNull(DruidDriver.getInstance());
    Assert.assertEquals("jdbc:wrap-jdbc:", driverWrapper.getAcceptPrefix());
    Assert.assertTrue(driverWrapper.getDataSourceUrls().length > 0);
    driverWrapper.getPropertyInfo(url_0, new Properties());
    Assert.assertFalse(driverWrapper.acceptsURL(null));
    Assert.assertFalse(driverWrapper.acceptsURL("xxx"));
    Assert.assertTrue(driverWrapper.acceptsURL(url_1));
    Connection connection_1 = DriverManager.getConnection(url_1);
    ConnectionProxy connection_wrapper_1 = connection_1.unwrap(ConnectionProxy.class);
    DataSourceProxy dataSource_1 = connection_wrapper_1.getDirectDataSource();
    Assert.assertEquals(1, dataSource_1.getProxyFilters().size());
    {
        Connection connection_2 = DriverManager.getConnection(url_2);
        ConnectionProxy connection_wrapper_2 = connection_2.unwrap(ConnectionProxy.class);
        DataSourceProxy dataSource_2 = connection_wrapper_2.getDirectDataSource();
        Assert.assertEquals(1, dataSource_2.getProxyFilters().size());
    }
    {
        Connection connection_3 = DriverManager.getConnection(url_3);
        ConnectionProxy connection_wrapper_3 = connection_3.unwrap(ConnectionProxy.class);
        DataSourceProxy dataSource_3 = connection_wrapper_3.getDirectDataSource();
        Assert.assertEquals(1, dataSource_3.getProxyFilters().size());
    }
    {
        Connection connection_4 = DriverManager.getConnection(url_4);
        ConnectionProxy connection_wrapper_4 = connection_4.unwrap(ConnectionProxy.class);
        DataSourceProxy dataSource_4 = connection_wrapper_4.getDirectDataSource();
        dataSource_4.getProxyFilters().toString();
        Assert.assertEquals(1, dataSource_4.getProxyFilters().size());
    }
}

Example 25 with ConnectionProxy

use of com.alibaba.druid.proxy.jdbc.ConnectionProxy in project druid by alibaba.

the class JdbcFilterEventAdapterTest method test_filterEventAdapter.

public void test_filterEventAdapter() throws Exception {
    DataSourceProxyConfig config = new DataSourceProxyConfig();
    DataSourceProxy dataSource = new DataSourceProxyImpl(null, config);
    FilterEventAdapter filter = new FilterEventAdapter() {
    };
    String sql = "SELECT * FROM PATROL";
    ConnectionProxy connection = new ConnectionProxyImpl(dataSource, null, new Properties(), 1001);
    final PreparedStatementProxy statement = new PreparedStatementProxyImpl(connection, null, sql, 1002);
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean statement_execute(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_execute(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int[] statement_executeBatch(StatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeBatch(chain, statement);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_executeQuery(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeQuery(chain, statement, sql);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int preparedStatement_executeUpdate(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeUpdate(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int autoGeneratedKeys) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, Statement.NO_GENERATED_KEYS);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, int[] columnIndexes) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new int[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public int statement_executeUpdate(StatementProxy statement, String sql, String[] columnNames) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.statement_executeUpdate(chain, statement, sql, new String[0]);
        } catch (Throwable ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // ///////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_getGeneratedKeys(StatementProxy statement) throws SQLException {
                return null;
            }
        };
        filter.statement_getGeneratedKeys(chain, statement);
    }
    {
        final ResultSetProxy resultSet = new ResultSetProxyImpl(statement, null, 2001, null);
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy statement_getGeneratedKeys(StatementProxy statement) throws SQLException {
                return resultSet;
            }
        };
        filter.statement_getGeneratedKeys(chain, statement);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public boolean preparedStatement_execute(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_execute(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public ResultSetProxy preparedStatement_executeQuery(PreparedStatementProxy statement) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.preparedStatement_executeQuery(chain, statement);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public void dataSource_recycle(DruidPooledConnection connection) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_releaseConnection(chain, null);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    // //////////////////////////
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new SQLException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (SQLException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new RuntimeException();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (RuntimeException ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
    {
        FilterChain chain = new FilterChainImpl(new DataSourceProxyImpl(null, config)) {

            public DruidPooledConnection dataSource_connect(DruidDataSource dataSource, long maxWaitMillis) throws SQLException {
                throw new Error();
            }
        };
        Throwable error = null;
        try {
            filter.dataSource_getConnection(chain, null, 0L);
        } catch (Error ex) {
            error = ex;
        }
        Assert.assertNotNull(error);
    }
}