content: package com.alibaba.druid.bvt.pool;
  
  import com.alibaba.druid.filter.FilterAdapter;
  import com.alibaba.druid.filter.FilterChain;
  import com.alibaba.druid.pool.DruidDataSource;
  import com.alibaba.druid.pool.DruidPooledStatement;
  import com.alibaba.druid.proxy.jdbc.ResultSetProxy;
  import com.alibaba.druid.proxy.jdbc.StatementProxy;
  import junit.framework.TestCase;
  
  import java.sql.Connection;
  import java.sql.SQLException;
  import java.sql.SQLFeatureNotSupportedException;
  import java.sql.SQLWarning;
  import java.sql.Statement;
  
  public class DruidPooledStatementTest extends TestCase {
      private DruidDataSource dataSource;
  
      protected void setUp() throws Exception {
          dataSource = new DruidDataSource();
          dataSource.setUrl("jdbc:mock:xxx");
          dataSource.setTestOnBorrow(false);
          dataSource.getProxyFilters().add(new ErrorFilter());
      }
  
      protected void tearDown() throws Exception {
          dataSource.close();
      }
  
      public void test_executeQuery_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeQuery("select 1");
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_executeUpdate_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeUpdate("select 1");
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_executeUpdate_error_1() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeUpdate("select 1", Statement.RETURN_GENERATED_KEYS);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_executeUpdate_error_2() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeUpdate("select 1", new int[0]);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_executeUpdate_error_3() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeUpdate("select 1", new String[0]);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_execute_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.execute("select 1");
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_execute_error_1() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.execute("select 1", Statement.RETURN_GENERATED_KEYS);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_execute_error_2() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.execute("select 1", new int[0]);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_execute_error_3() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.execute("select 1", new String[0]);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getMaxFieldSize_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getMaxFieldSize();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setMaxFieldSize_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setMaxFieldSize(0);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getMaxRows_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getMaxRows();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setMaxRows_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setMaxRows(0);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setEscapeProcessing_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setEscapeProcessing(true);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getQueryTimeout_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getQueryTimeout();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setQueryTimeout_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setQueryTimeout(-1);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_cancel_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.cancel();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getWarnings_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getWarnings();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_clearWarnings_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.clearWarnings();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setCursorName_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setCursorName(null);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getResultSet_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getResultSet();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
          assertEquals(0, dataSource.getDataSourceStat().getResultSetStat().getOpenCount());
      }
  
      public void test_getUpdateCount_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getUpdateCount();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getMoreResults_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getMoreResults();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setFetchDirection_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setFetchDirection(0);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getFetchDirection_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getFetchDirection();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_setFetchSize_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.setFetchSize(0);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getFetchSize_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getFetchSize();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getResultSetConcurrency_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getResultSetConcurrency();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getResultSetType_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getResultSetType();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_addBatch_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.addBatch("select 1");
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_clearBatch_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.clearBatch();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_executeBatch_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.executeBatch();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getMoreResults_error_1() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getMoreResults(0);
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getGeneratedKeys_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getGeneratedKeys();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_getResultSetHoldability_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          Statement stmt = conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.getResultSetHoldability();
          } catch (Exception e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(1, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_closeOnCompletion_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          DruidPooledStatement stmt = (DruidPooledStatement) conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.closeOnCompletion();
          } catch (SQLFeatureNotSupportedException e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(0, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      public void test_isCloseOnCompletion_error() throws Exception {
          Connection conn = dataSource.getConnection();
  
          DruidPooledStatement stmt = (DruidPooledStatement) conn.createStatement();
  
          assertEquals(0, dataSource.getPoolingCount());
          assertEquals(1, dataSource.getActiveCount());
          assertEquals(0, dataSource.getErrorCount());
  
          Exception error = null;
          try {
              stmt.isCloseOnCompletion();
          } catch (SQLFeatureNotSupportedException e) {
              error = e;
          }
          assertNotNull(error);
  
          assertEquals(0, dataSource.getErrorCount());
  
          stmt.close();
          conn.close();
  
          assertEquals(1, dataSource.getPoolingCount());
          assertEquals(0, dataSource.getActiveCount());
      }
  
      private final class ErrorFilter extends FilterAdapter {
          @Override
          public ResultSetProxy statement_executeQuery(FilterChain chain, StatementProxy statement, String sql)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_executeUpdate(FilterChain chain, StatementProxy statement, String sql) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_executeUpdate(FilterChain chain, StatementProxy statement, String sql,
                                             int autoGeneratedKeys) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_executeUpdate(FilterChain chain, StatementProxy statement, String sql, int[] columnIndexes)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_executeUpdate(FilterChain chain, StatementProxy statement, String sql,
                                             String[] columnNames) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_execute(FilterChain chain, StatementProxy statement, String sql) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_execute(FilterChain chain, StatementProxy statement, String sql, int autoGeneratedKeys)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_execute(FilterChain chain, StatementProxy statement, String sql, int[] columnIndexes)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_execute(FilterChain chain, StatementProxy statement, String sql, String[] columnNames)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getMaxFieldSize(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getMaxRows(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setMaxFieldSize(FilterChain chain, StatementProxy statement, int max) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setMaxRows(FilterChain chain, StatementProxy statement, int max) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setEscapeProcessing(FilterChain chain, StatementProxy statement, boolean enable)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getQueryTimeout(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setQueryTimeout(FilterChain chain, StatementProxy statement, int seconds)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_cancel(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public SQLWarning statement_getWarnings(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_clearWarnings(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setCursorName(FilterChain chain, StatementProxy statement, String name)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public ResultSetProxy statement_getResultSet(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getUpdateCount(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_getMoreResults(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setFetchDirection(FilterChain chain, StatementProxy statement, int value)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getFetchDirection(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getFetchSize(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_setFetchSize(FilterChain chain, StatementProxy statement, int value) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getResultSetConcurrency(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getResultSetType(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_addBatch(FilterChain chain, StatementProxy statement, String sql) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public void statement_clearBatch(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int[] statement_executeBatch(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public boolean statement_getMoreResults(FilterChain chain, StatementProxy statement, int current)
                  throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public ResultSetProxy statement_getGeneratedKeys(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
  
          @Override
          public int statement_getResultSetHoldability(FilterChain chain, StatementProxy statement) throws SQLException {
              throw new SQLException();
          }
      }
  }
  