content: /*
   * Copyright 1999-2018 Alibaba Group Holding Ltd.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package com.alibaba.druid.bvt.pool.basic;
  
  import com.alibaba.druid.mock.MockResultSet;
  import com.alibaba.druid.pool.DruidPooledResultSet;
  import com.alibaba.druid.pool.DruidPooledStatement;
  import junit.framework.TestCase;
  
  import java.sql.ResultSet;
  import java.sql.SQLException;
  
  public class ResultSetTest2 extends TestCase {
      private DruidPooledStatement stmt;
      private MockResultSet raw;
      private DruidPooledResultSet resultSet;
  
      protected void setUp() throws Exception {
          stmt = new DruidPooledStatement(null, null) {
              protected SQLException checkException(Throwable error) throws SQLException {
                  if (error instanceof SQLException) {
                      return (SQLException) error;
                  }
  
                  return new SQLException(error);
              }
          };
  
          raw = new MockResultSet(null);
          raw.getRows().add(new Object[]{null});
          resultSet = new DruidPooledResultSet(stmt, raw);
      }
  
      public void test_rowDeleted() throws Exception {
          resultSet.rowDeleted();
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.rowDeleted();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_rowInserted() throws Exception {
          resultSet.rowInserted();
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.rowInserted();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_rowUpdated() throws Exception {
          resultSet.rowInserted();
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.rowUpdated();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getConcurrency() throws Exception {
          resultSet.getConcurrency();
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getConcurrency();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getType() throws Exception {
          resultSet.getType();
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getType();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_FetchSize() throws Exception {
          resultSet.setFetchSize(10);
          assertEquals(10, resultSet.getFetchSize());
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getFetchSize();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
          {
              SQLException error = null;
              try {
                  resultSet.setFetchSize(10);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_FetchDirection() throws Exception {
          resultSet.setFetchDirection(ResultSet.FETCH_REVERSE);
          assertEquals(ResultSet.FETCH_REVERSE, resultSet.getFetchDirection());
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getFetchDirection();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
          {
              SQLException error = null;
              try {
                  resultSet.setFetchDirection(ResultSet.FETCH_REVERSE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getHoldability() throws Exception {
          resultSet.getHoldability();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getHoldability();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getStatement() throws Exception {
          resultSet.getStatement();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  raw.getStatement();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_moveToCurrentRow() throws Exception {
          resultSet.moveToCurrentRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.moveToCurrentRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_moveToInsertRow() throws Exception {
          resultSet.moveToInsertRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.moveToInsertRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_cancelRowUpdates() throws Exception {
          resultSet.cancelRowUpdates();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.cancelRowUpdates();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_refreshRow() throws Exception {
          resultSet.refreshRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.refreshRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_deleteRow() throws Exception {
          resultSet.deleteRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.deleteRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateRow() throws Exception {
          resultSet.updateRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.updateRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_insertRow() throws Exception {
          resultSet.insertRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.insertRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_previous() throws Exception {
          resultSet.previous();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.previous();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_relative() throws Exception {
          resultSet.relative(1);
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.relative(1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_absolute() throws Exception {
          resultSet.absolute(1);
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.absolute(1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_next() throws Exception {
          resultSet.next();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.next();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_wasNull() throws Exception {
          resultSet.wasNull();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.wasNull();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_isBeforeFirst() throws Exception {
          resultSet.isBeforeFirst();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.isBeforeFirst();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_isAfterLast() throws Exception {
          resultSet.isAfterLast();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.isAfterLast();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_isFirst() throws Exception {
          resultSet.isFirst();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.isFirst();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_isLast() throws Exception {
          resultSet.isLast();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.isLast();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_beforeFirst() throws Exception {
          resultSet.beforeFirst();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.beforeFirst();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_first() throws Exception {
          resultSet.first();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.first();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_afterLast() throws Exception {
          resultSet.afterLast();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.afterLast();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_last() throws Exception {
          resultSet.last();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.last();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getRow() throws Exception {
          resultSet.getRow();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getRow();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getWarnings() throws Exception {
          resultSet.getWarnings();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getWarnings();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_clearWarnings() throws Exception {
          resultSet.clearWarnings();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.clearWarnings();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getCursorName() throws Exception {
          resultSet.getCursorName();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getCursorName();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getMetaData() throws Exception {
          resultSet.getMetaData();
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.getMetaData();
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_findColumn() throws Exception {
          resultSet.findColumn("1");
  
          raw.close();
  
          {
              SQLException error = null;
              try {
                  resultSet.findColumn("xxxx");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_closeError() throws Exception {
          MockResultSet mock = new MockResultSet(null) {
              public void close() throws SQLException {
                  throw new SQLException();
              }
          };
  
          DruidPooledResultSet rs = new DruidPooledResultSet(stmt, mock);
  
          SQLException error = null;
          try {
              rs.close();
          } catch (SQLException ex) {
              error = ex;
          }
          assertNotNull(error);
      }
  }
  