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.io.InputStream;
  import java.io.Reader;
  import java.math.BigDecimal;
  import java.sql.Blob;
  import java.sql.Clob;
  import java.sql.NClob;
  import java.sql.Ref;
  import java.sql.SQLException;
  import java.sql.SQLXML;
  
  public class ResultSetTest 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);
      }
  
      @SuppressWarnings("deprecation")
      public void test_get() throws Exception {
          assertTrue(stmt == resultSet.getPoolableStatement());
          assertTrue(raw == resultSet.getRawResultSet());
  
          assertTrue(resultSet.next());
          assertTrue(resultSet.wasNull() == false);
          resultSet.getString(1);
          assertTrue(resultSet.wasNull());
          resultSet.getBoolean(1);
          resultSet.getByte(1);
          resultSet.getShort(1);
          resultSet.getInt(1);
          resultSet.getLong(1);
          resultSet.getFloat(1);
          resultSet.getDouble(1);
          resultSet.getBigDecimal(1);
          resultSet.getBigDecimal(1, 1);
          resultSet.getBytes(1);
          resultSet.getDate(1);
          resultSet.getTime(1);
          resultSet.getTimestamp(1);
          resultSet.getAsciiStream(1);
          resultSet.getUnicodeStream(1);
          resultSet.getBinaryStream(1);
  
          resultSet.getString("1");
          resultSet.getBoolean("1");
          resultSet.getByte("1");
          resultSet.getShort("1");
          resultSet.getInt("1");
          resultSet.getLong("1");
          resultSet.getFloat("1");
          resultSet.getDouble("1");
          resultSet.getBigDecimal("1");
          resultSet.getBigDecimal("1", 1);
          resultSet.getBytes("1");
          resultSet.getDate("1");
          resultSet.getTime("1");
          resultSet.getTimestamp("1");
          resultSet.getAsciiStream("1");
          resultSet.getUnicodeStream("1");
          resultSet.getBinaryStream("1");
      }
  
      public void test_set() throws Exception {
          long currentMillis = System.currentTimeMillis();
  
          assertTrue(resultSet.next());
  
          resultSet.updateNull(1);
          assertNull(resultSet.getString(1));
          resultSet.updateBoolean(1, true);
          assertEquals(true, resultSet.getBoolean(1));
  
          resultSet.updateByte(1, (byte) 12);
          assertEquals(12, resultSet.getByte(1));
  
          resultSet.updateShort(1, (short) 23);
          assertEquals(23, resultSet.getShort(1));
  
          resultSet.updateInt(1, 34);
          assertEquals(34, resultSet.getInt(1));
  
          resultSet.updateLong(1, 45);
          assertEquals(45, resultSet.getLong(1));
  
          resultSet.updateFloat(1, 1.0F);
          assertEquals(true, 1.0F == resultSet.getFloat(1));
  
          resultSet.updateDouble(1, 2.0D);
          assertEquals(true, 2.0D == resultSet.getDouble(1));
  
          resultSet.updateBigDecimal(1, new BigDecimal("33"));
          assertEquals(new BigDecimal("33"), resultSet.getBigDecimal(1));
  
          resultSet.updateString(1, "xxx");
          assertEquals("xxx", resultSet.getString(1));
  
          resultSet.updateBytes(1, new byte[0]);
          assertEquals(0, resultSet.getBytes(1).length);
  
          resultSet.updateDate(1, new java.sql.Date(currentMillis));
          assertEquals(new java.sql.Date(currentMillis), resultSet.getDate(1));
  
          resultSet.updateTime(1, new java.sql.Time(1000));
          assertEquals(new java.sql.Time(1000), resultSet.getTime(1));
  
          resultSet.updateTimestamp(1, new java.sql.Timestamp(currentMillis));
          assertEquals(new java.sql.Timestamp(currentMillis), resultSet.getTimestamp(1));
      }
  
      public void test_set_error() throws Exception {
          long currentMillis = System.currentTimeMillis();
  
          assertTrue(resultSet.next());
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNull(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBoolean(0, true);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateByte(0, (byte) 12);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateShort(0, (short) 23);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateInt(0, 34);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateLong(0, 45);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateFloat(0, 1.0F);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateDouble(0, 2.0D);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBigDecimal(0, new BigDecimal("33"));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateString(0, "xxx");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBytes(0, new byte[0]);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateDate(0, new java.sql.Date(currentMillis));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateTime(0, new java.sql.Time(1000));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateTimestamp(0, new java.sql.Timestamp(currentMillis));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
      }
  
      public void test_setByName() throws Exception {
          long currentMillis = System.currentTimeMillis();
  
          assertTrue(resultSet.next());
  
          resultSet.updateNull("1");
          assertNull(resultSet.getString(1));
          resultSet.updateBoolean("1", true);
          assertEquals(true, resultSet.getBoolean("1"));
  
          resultSet.updateByte("1", (byte) 12);
          assertEquals(12, resultSet.getByte("1"));
  
          resultSet.updateShort("1", (short) 23);
          assertEquals(23, resultSet.getShort("1"));
  
          resultSet.updateInt("1", 34);
          assertEquals(34, resultSet.getInt("1"));
  
          resultSet.updateLong("1", 45);
          assertEquals(45, resultSet.getLong("1"));
  
          resultSet.updateFloat("1", 1.0F);
          assertEquals(true, 1.0F == resultSet.getFloat("1"));
  
          resultSet.updateDouble("1", 2.0D);
          assertEquals(true, 2.0D == resultSet.getDouble("1"));
  
          resultSet.updateBigDecimal("1", new BigDecimal("33"));
          assertEquals(new BigDecimal("33"), resultSet.getBigDecimal("1"));
  
          resultSet.updateString("1", "xxx");
          assertEquals("xxx", resultSet.getString("1"));
  
          resultSet.updateBytes("1", new byte[0]);
          assertEquals(0, resultSet.getBytes("1").length);
  
          resultSet.updateDate("1", new java.sql.Date(currentMillis));
          assertEquals(new java.sql.Date(currentMillis), resultSet.getDate("1"));
  
          resultSet.updateTime("1", new java.sql.Time(1000));
          assertEquals(new java.sql.Time(1000), resultSet.getTime("1"));
  
          resultSet.updateTimestamp("1", new java.sql.Timestamp(currentMillis));
          assertEquals(new java.sql.Timestamp(currentMillis), resultSet.getTimestamp("1"));
      }
  
      public void test_updateByLabel_error() throws Exception {
          long currentMillis = System.currentTimeMillis();
  
          assertTrue(resultSet.next());
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNull("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBoolean("0", true);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateByte("0", (byte) 12);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateShort("0", (short) 23);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateInt("0", 34);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateLong("0", 45);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateFloat("0", 1.0F);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateDouble("0", 2.0D);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBigDecimal("0", new BigDecimal("33"));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateString("0", "xxx");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBytes("0", new byte[0]);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateDate("0", new java.sql.Date(currentMillis));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateTime("0", new java.sql.Time(1000));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateTimestamp("0", new java.sql.Timestamp(currentMillis));
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
      }
  
      public void test_updateBinaryStream() throws Exception {
          resultSet.next();
  
          resultSet.updateBinaryStream(1, (InputStream) null);
          resultSet.updateBinaryStream("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateBinaryStream_2() throws Exception {
          resultSet.next();
  
          resultSet.updateBinaryStream(1, (InputStream) null, 1L);
          resultSet.updateBinaryStream("1", (InputStream) null, 1L);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream("0", (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream(0, (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateCharacterStream() throws Exception {
          resultSet.next();
  
          resultSet.updateCharacterStream(1, (Reader) null);
          resultSet.updateCharacterStream("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_blob() throws Exception {
          resultSet.next();
  
          resultSet.updateBlob(1, (InputStream) null);
          resultSet.updateBlob("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_clob() throws Exception {
          resultSet.next();
  
          resultSet.updateClob(1, (Reader) null);
          resultSet.updateClob("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_nclob() throws Exception {
          resultSet.next();
  
          resultSet.updateNClob(1, (Reader) null);
          resultSet.updateNClob("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_nclob_1() throws Exception {
          resultSet.next();
  
          resultSet.updateNClob(1, (Reader) null, 1);
          resultSet.updateNClob("1", (Reader) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob("0", (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob(0, (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_clob_1() throws Exception {
          resultSet.next();
  
          resultSet.updateClob(1, (Reader) null, 1);
          resultSet.updateClob("1", (Reader) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob("0", (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob(0, (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_update_blob_1() throws Exception {
          resultSet.next();
  
          resultSet.updateBlob(1, (InputStream) null, 1);
          resultSet.updateBlob("1", (InputStream) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob("0", (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob(0, (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateCharacterStream_1() throws Exception {
          resultSet.next();
  
          resultSet.updateCharacterStream(1, (Reader) null, 1);
          resultSet.updateCharacterStream("1", (Reader) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream("0", (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream(0, (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateAsciiStream_1() throws Exception {
          resultSet.next();
  
          resultSet.updateAsciiStream(1, (InputStream) null, 1);
          resultSet.updateAsciiStream("1", (InputStream) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream("0", (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream(0, (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateAsciiStream_2() throws Exception {
          resultSet.next();
  
          resultSet.updateAsciiStream(1, (InputStream) null, 1L);
          resultSet.updateAsciiStream("1", (InputStream) null, 1L);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream("0", (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream(0, (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateBinaryStream_1() throws Exception {
          resultSet.next();
  
          resultSet.updateBinaryStream(1, (InputStream) null, 1);
          resultSet.updateBinaryStream("1", (InputStream) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream("0", (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBinaryStream(0, (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateAsciiStream() throws Exception {
          resultSet.next();
  
          resultSet.updateAsciiStream(1, (InputStream) null);
          resultSet.updateAsciiStream("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateAsciiStream(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateNCharacterStream() throws Exception {
          resultSet.next();
  
          resultSet.updateNCharacterStream(1, (Reader) null);
          resultSet.updateNCharacterStream("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNCharacterStream("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNCharacterStream(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateNCharacterStream_1() throws Exception {
          resultSet.next();
  
          resultSet.updateNCharacterStream(1, (Reader) null, 1);
          resultSet.updateNCharacterStream("1", (Reader) null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNCharacterStream("0", (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNCharacterStream(0, (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateSQLXML() throws Exception {
          resultSet.next();
  
          resultSet.updateSQLXML(1, (SQLXML) null);
          resultSet.updateSQLXML("1", (SQLXML) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateSQLXML("0", (SQLXML) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateSQLXML(0, (SQLXML) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_get_error() throws Exception {
          {
              SQLException error = null;
              try {
                  resultSet.getString(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBoolean(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getByte(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getShort(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getInt(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getLong(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getFloat(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getDouble(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBigDecimal(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBigDecimal(0, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBytes(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getDate(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTime(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTimestamp(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getAsciiStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getUnicodeStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBinaryStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          // ////////////////
  
          {
              SQLException error = null;
              try {
                  resultSet.getString("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBoolean("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getByte("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getShort("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getInt("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getLong("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getFloat("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getDouble("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBigDecimal("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBigDecimal("0", 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBytes("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getDate("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTime("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTimestamp("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getAsciiStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getUnicodeStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBinaryStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getSQLXML() throws Exception {
          resultSet.next();
  
          resultSet.getSQLXML(1);
          resultSet.getSQLXML("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getSQLXML(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getSQLXML("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getNClob() throws Exception {
          resultSet.next();
  
          resultSet.getNClob(1);
          resultSet.getNClob("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getNClob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getNClob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getNString() throws Exception {
          resultSet.next();
  
          resultSet.getNString(1);
          resultSet.getNString("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getNString(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getNString("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getNCharacterStream() throws Exception {
          resultSet.next();
  
          resultSet.getNCharacterStream(1);
          resultSet.getNCharacterStream("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getNCharacterStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getNCharacterStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getCharacterStream() throws Exception {
          resultSet.next();
  
          resultSet.getCharacterStream(1);
          resultSet.getCharacterStream("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getCharacterStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getCharacterStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateCharacterStream_2() throws Exception {
          resultSet.next();
  
          resultSet.updateCharacterStream(1, (Reader) null, 1L);
          resultSet.updateCharacterStream("1", (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream("0", (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateCharacterStream(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getURL() throws Exception {
          resultSet.next();
  
          resultSet.getURL(1);
          resultSet.getURL("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getURL(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getURL("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getRowId() throws Exception {
          resultSet.next();
  
          resultSet.getRowId(1);
          resultSet.getRowId("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getRowId(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getRowId("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getObject_1() throws Exception {
          resultSet.next();
  
          resultSet.getObject(1);
          resultSet.getObject("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getObject(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getObject("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTimestamp() throws Exception {
          resultSet.next();
  
          resultSet.getTimestamp(1, null);
          resultSet.getTimestamp("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.getTimestamp(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTimestamp("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTime() throws Exception {
          resultSet.next();
  
          resultSet.getTime(1, null);
          resultSet.getTime("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.getTime(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getTime("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getDate() throws Exception {
          resultSet.next();
  
          resultSet.getDate(1, null);
          resultSet.getDate("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.getDate(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getDate("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getArray() throws Exception {
          resultSet.next();
  
          resultSet.getArray(1);
          resultSet.getArray("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getArray(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getArray("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getClob() throws Exception {
          resultSet.next();
  
          resultSet.getClob(1);
          resultSet.getClob("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getClob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getClob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getBlob() throws Exception {
          resultSet.next();
  
          resultSet.getBlob(1);
          resultSet.getBlob("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getBlob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getBlob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getRef() throws Exception {
          resultSet.next();
  
          resultSet.getRef(1);
          resultSet.getRef("1");
  
          {
              SQLException error = null;
              try {
                  resultSet.getRef(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getRef("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getObject() throws Exception {
          resultSet.next();
  
          resultSet.getObject(1, (java.util.Map) null);
          resultSet.getObject("1", (java.util.Map) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.getObject(0, (java.util.Map) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.getObject("0", (java.util.Map) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateNClob() throws Exception {
          resultSet.next();
  
          resultSet.updateNClob(1, (NClob) null);
          resultSet.updateNClob("1", (NClob) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob(0, (NClob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNClob("0", (NClob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateNString() throws Exception {
          resultSet.next();
  
          resultSet.updateNString(1, null);
          resultSet.updateNString("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNString(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateNString("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateRowId() throws Exception {
          resultSet.next();
  
          resultSet.updateRowId(1, null);
          resultSet.updateRowId("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateRowId(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateRowId("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateArray() throws Exception {
          resultSet.next();
  
          resultSet.updateArray(1, null);
          resultSet.updateArray("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateArray(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateArray("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateClob() throws Exception {
          resultSet.next();
  
          resultSet.updateClob(1, (Clob) null);
          resultSet.updateClob("1", (Clob) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob(0, (Clob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateClob("0", (Clob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateBlob() throws Exception {
          resultSet.next();
  
          resultSet.updateBlob(1, (Blob) null);
          resultSet.updateBlob("1", (Blob) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob(0, (Blob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateBlob("0", (Blob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateRef() throws Exception {
          resultSet.next();
  
          resultSet.updateRef(1, (Ref) null);
          resultSet.updateRef("1", (Ref) null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateRef(0, (Ref) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateRef("0", (Ref) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateObject() throws Exception {
          resultSet.next();
  
          resultSet.updateObject(1, null);
          resultSet.updateObject("1", null);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateObject(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateObject("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateObject_1() throws Exception {
          resultSet.next();
  
          resultSet.updateObject(1, null, 1);
          resultSet.updateObject("1", null, 1);
  
          {
              SQLException error = null;
              try {
                  resultSet.updateObject(0, null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  resultSet.updateObject("0", null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  }
  