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.MockCallableStatement;
  import com.alibaba.druid.mock.MockConnection;
  import com.alibaba.druid.pool.DruidConnectionHolder;
  import com.alibaba.druid.pool.DruidDataSource;
  import com.alibaba.druid.pool.DruidPooledCallableStatement;
  import com.alibaba.druid.pool.DruidPooledConnection;
  import com.alibaba.druid.pool.DruidPooledPreparedStatement.PreparedStatementKey;
  import com.alibaba.druid.pool.PreparedStatementHolder;
  import junit.framework.TestCase;
  
  import java.io.InputStream;
  import java.io.Reader;
  import java.sql.*;
  
  public class PoolableCallableStatementTest extends TestCase {
      private DruidDataSource dataSource = new DruidDataSource();
      protected DruidPooledConnection conn;
      protected MockCallableStatement raw;
      protected DruidPooledCallableStatement stmt;
  
      protected void setUp() throws Exception {
          MockConnection mockConn = new MockConnection();
          DruidConnectionHolder connHolder = new DruidConnectionHolder(dataSource, mockConn, 0);
          conn = new DruidPooledConnection(connHolder);
          raw = new MockCallableStatement(null, null);
          stmt = new DruidPooledCallableStatement(conn, new PreparedStatementHolder(new PreparedStatementKey("", null,
                  null, 0, 0,
                  0), raw)) {
              protected SQLException checkException(Throwable error) throws SQLException {
                  if (error instanceof SQLException) {
                      return (SQLException) error;
                  }
  
                  return new SQLException(error);
              }
          };
  
          assertEquals(0, raw.getOutParameters().size());
          stmt.registerOutParameter(1, Types.INTEGER);
          assertEquals(1, raw.getOutParameters().size());
  
          stmt.registerOutParameter(2, Types.DECIMAL, 10);
          assertEquals(2, raw.getOutParameters().size());
      }
  
      public void test_executeQuery_large() throws Exception {
          for (int i = 0; i < 1000 * 1000; ++i) {
              ResultSet rs = stmt.executeQuery();
              rs.close();
          }
      }
  
      public void test_basic() throws Exception {
          assertEquals(raw, stmt.getCallableStatementRaw());
      }
  
      @SuppressWarnings("deprecation")
      public void test_callableStmt() throws Exception {
          assertTrue(stmt.wasNull() == false);
          stmt.getString(1);
          assertTrue(stmt.wasNull());
          stmt.getBoolean(1);
          stmt.getByte(1);
          stmt.getShort(1);
          stmt.getInt(1);
          stmt.getLong(1);
          stmt.getFloat(1);
          stmt.getDouble(1);
          stmt.getBigDecimal(1);
          stmt.getBigDecimal(1, 1);
          stmt.getBytes(1);
          stmt.getDate(1);
          stmt.getTime(1);
          stmt.getTimestamp(1);
          stmt.getObject(1);
          stmt.getRef(1);
          stmt.getBlob(1);
  
          stmt.getString("1");
          stmt.getBoolean("1");
          stmt.getByte("1");
          stmt.getShort("1");
          stmt.getInt("1");
          stmt.getLong("1");
          stmt.getFloat("1");
          stmt.getDouble("1");
          stmt.getBigDecimal("1");
          stmt.getBytes("1");
          stmt.getDate("1");
          stmt.getTime("1");
          stmt.getTimestamp("1");
          stmt.getObject("1");
          stmt.getRef("1");
          stmt.getBlob("1");
      }
  
      public void test_getByLabel_error() {
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          // ////////////////
  
          {
              SQLException error = null;
              try {
                  stmt.getString("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBoolean("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getByte("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getShort("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getInt("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getLong("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getFloat("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDouble("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBigDecimal("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBytes("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDate("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTime("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getObject("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getRef("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBlob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      @SuppressWarnings("deprecation")
      public void test_get_error() {
          {
              SQLException error = null;
              try {
                  stmt.getString(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBoolean(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getByte(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getShort(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getInt(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getLong(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getFloat(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDouble(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBigDecimal(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBigDecimal(0, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBytes(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDate(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTime(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getObject(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getRef(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getBlob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
      }
  
      public void test_getNClob() throws Exception {
          stmt.getNClob(1);
          stmt.getNClob("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getNClob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getNClob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getNString() throws Exception {
          stmt.getNString(1);
          stmt.getNString("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getNString(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getNString("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getNCharacterStream() throws Exception {
          stmt.getNCharacterStream(1);
          stmt.getNCharacterStream("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getNCharacterStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getNCharacterStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getCharacterStream() throws Exception {
          stmt.getCharacterStream(1);
          stmt.getCharacterStream("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getCharacterStream(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getCharacterStream("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateCharacterStream_2() throws Exception {
          stmt.setCharacterStream(1, (Reader) null, 1L);
          stmt.setCharacterStream("1", (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream("0", (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNClob() throws Exception {
          stmt.setNClob(1, (Reader) null);
          stmt.setNClob("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setClob() throws Exception {
          stmt.setClob(1, (Reader) null);
          stmt.setClob("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setClob("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setClob(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNCharacterStream() throws Exception {
          stmt.setNCharacterStream(1, (Reader) null);
          stmt.setNCharacterStream("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setNCharacterStream("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNCharacterStream(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setCharacterStream() throws Exception {
          stmt.setCharacterStream(1, (Reader) null);
          stmt.setCharacterStream("1", (Reader) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream("0", (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream(0, (Reader) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBinaryStream() throws Exception {
          stmt.setBinaryStream(1, (InputStream) null);
          stmt.setBinaryStream("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBinaryStream_1() throws Exception {
          stmt.setBinaryStream(1, (InputStream) null, 1);
          stmt.setBinaryStream("1", (InputStream) null, 1);
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream("0", (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream(0, (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBinaryStream_2() throws Exception {
          stmt.setBinaryStream(1, (InputStream) null, 1L);
          stmt.setBinaryStream("1", (InputStream) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream("0", (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream(0, (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setAsciiStream() throws Exception {
          stmt.setAsciiStream(1, (InputStream) null);
          stmt.setAsciiStream("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBlob() throws Exception {
          stmt.setBlob(1, (InputStream) null);
          stmt.setBlob("1", (InputStream) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob("0", (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob(0, (InputStream) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setClob_1() throws Exception {
          stmt.setClob(1, (Clob) null);
          stmt.setClob("1", (Clob) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setClob("0", (Clob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setClob(0, (Clob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setClob_2() throws Exception {
          stmt.setClob(1, (Reader) null, 1L);
          stmt.setClob("1", (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setClob("0", (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setClob(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setAsciiStream_1() throws Exception {
          stmt.setAsciiStream(1, (InputStream) null, 1L);
          stmt.setAsciiStream("1", (InputStream) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream("0", (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream(0, (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNull() throws Exception {
          stmt.setNull(1, Types.INTEGER, "Int");
          stmt.setNull("1", Types.INTEGER, "Int");
  
          {
              SQLException error = null;
              try {
                  stmt.setNull("0", Types.INTEGER, "Int");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNull(0, Types.INTEGER, "Int");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setTimestamp() throws Exception {
          stmt.setTimestamp(1, (Timestamp) null);
          stmt.setTimestamp("1", (Timestamp) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setTimestamp("0", (Timestamp) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setTimestamp(0, (Timestamp) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setTimestamp_1() throws Exception {
          stmt.setTimestamp(1, (Timestamp) null, null);
          stmt.setTimestamp("1", (Timestamp) null, null);
  
          {
              SQLException error = null;
              try {
                  stmt.setTimestamp("0", (Timestamp) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setTimestamp(0, (Timestamp) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setTime() throws Exception {
          stmt.setTime(1, (Time) null);
          stmt.setTime("1", (Time) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setTime("0", (Time) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setTime(0, (Time) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setTime_1() throws Exception {
          stmt.setTime(1, (Time) null, null);
          stmt.setTime("1", (Time) null, null);
  
          {
              SQLException error = null;
              try {
                  stmt.setTime("0", (Time) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setTime(0, (Time) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setDate() throws Exception {
          stmt.setDate(1, (Date) null);
          stmt.setDate("1", (Date) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setDate("0", (Date) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setDate(0, (Date) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setDate_1() throws Exception {
          stmt.setDate(1, (Date) null, null);
          stmt.setDate("1", (Date) null, null);
  
          {
              SQLException error = null;
              try {
                  stmt.setDate("0", (Date) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setDate(0, (Date) null, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setCharacterStream_1() throws Exception {
          stmt.setCharacterStream(1, (Reader) null, 1);
          stmt.setCharacterStream("1", (Reader) null, 1);
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream("0", (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream(0, (Reader) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setObject() throws Exception {
          stmt.setObject(1, null);
          stmt.setObject("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.setObject("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setObject(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setObject_1() throws Exception {
          stmt.setObject(1, null, Types.INTEGER);
          stmt.setObject("1", null, Types.INTEGER);
  
          {
              SQLException error = null;
              try {
                  stmt.setObject("0", null, Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setObject(0, null, Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setObject_2() throws Exception {
          stmt.setObject(1, null, Types.INTEGER, 2);
          stmt.setObject("1", null, Types.INTEGER, 2);
  
          {
              SQLException error = null;
              try {
                  stmt.setObject("0", null, Types.INTEGER, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setObject(0, null, Types.INTEGER, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setAsciiStream_2() throws Exception {
          stmt.setAsciiStream(1, (InputStream) null, 1);
          stmt.setAsciiStream("1", (InputStream) null, 1);
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream("0", (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream(0, (InputStream) null, 1);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBytes() throws Exception {
          stmt.setBytes(1, null);
          stmt.setBytes("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.setBytes("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBytes(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setString() throws Exception {
          stmt.setString(1, null);
          stmt.setString("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.setString("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setString(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBigDecimal() throws Exception {
          stmt.setBigDecimal(1, null);
          stmt.setBigDecimal("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.setBigDecimal("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBigDecimal(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setDouble() throws Exception {
          stmt.setDouble(1, 1.0D);
          stmt.setDouble("1", 1.0D);
  
          {
              SQLException error = null;
              try {
                  stmt.setDouble("0", 1.0D);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setDouble(0, 1.0D);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setFloat() throws Exception {
          stmt.setFloat(1, 1.0F);
          stmt.setFloat("1", 1.0F);
  
          {
              SQLException error = null;
              try {
                  stmt.setFloat("0", 1.0F);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setFloat(0, 1.0F);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setLong() throws Exception {
          stmt.setLong(1, 2);
          stmt.setLong("1", 2);
  
          {
              SQLException error = null;
              try {
                  stmt.setLong("0", 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setLong(0, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setInt() throws Exception {
          stmt.setInt(1, 2);
          stmt.setInt("1", 2);
  
          {
              SQLException error = null;
              try {
                  stmt.setInt("0", 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setInt(0, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setShort() throws Exception {
          stmt.setShort(1, Short.MAX_VALUE);
          stmt.setShort("1", Short.MAX_VALUE);
  
          {
              SQLException error = null;
              try {
                  stmt.setShort("0", Short.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setShort(0, Short.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setByte() throws Exception {
          stmt.setByte(1, Byte.MAX_VALUE);
          stmt.setByte("1", Byte.MAX_VALUE);
  
          {
              SQLException error = null;
              try {
                  stmt.setByte("0", Byte.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setByte(0, Byte.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getClob() throws Exception {
          stmt.getClob(1);
          stmt.getClob("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getClob(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getClob("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getArray() throws Exception {
          stmt.getArray(1);
          stmt.getArray("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getArray(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getArray("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getDate() throws Exception {
          stmt.getDate(1);
          stmt.getDate("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getDate(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDate("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getDate_1() throws Exception {
          stmt.getDate(1, null);
          stmt.getDate("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.getDate(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getDate("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTime() throws Exception {
          stmt.getTime(1);
          stmt.getTime("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getTime(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTime("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTime_1() throws Exception {
          stmt.getTime(1, null);
          stmt.getTime("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.getTime(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTime("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTimestamp() throws Exception {
          stmt.getTimestamp(1);
          stmt.getTimestamp("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getTimestamp_1() throws Exception {
          stmt.getTimestamp(1, null);
          stmt.getTimestamp("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getTimestamp("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getURL() throws Exception {
          stmt.getURL(1);
          stmt.getURL("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getURL(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getURL("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBlob_1() throws Exception {
          stmt.setBlob(1, (Blob) null);
          stmt.setBlob("1", (Blob) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob("0", (Blob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob(0, (Blob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setSQLXML() throws Exception {
          stmt.setSQLXML(1, (SQLXML) null);
          stmt.setSQLXML("1", (SQLXML) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setSQLXML("0", (SQLXML) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setSQLXML(0, (SQLXML) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getSQLXML() throws Exception {
          stmt.getSQLXML(1);
          stmt.getSQLXML("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getSQLXML(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getSQLXML("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBlob_2() throws Exception {
          stmt.setBlob(1, (InputStream) null, 1L);
          stmt.setBlob("1", (InputStream) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob("0", (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBlob(0, (InputStream) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNClob_1() throws Exception {
          stmt.setNClob(1, (Reader) null, 1L);
          stmt.setNClob("1", (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob("0", (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNCharacterStream_1() throws Exception {
          stmt.setNCharacterStream(1, (Reader) null, 1L);
          stmt.setNCharacterStream("1", (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setNCharacterStream("0", (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNCharacterStream(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setRowId() throws Exception {
          stmt.setRowId(1, (RowId) null);
          stmt.setRowId("1", (RowId) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setRowId("0", (RowId) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setRowId(0, (RowId) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getRowId() throws Exception {
          stmt.getRowId(1);
          stmt.getRowId("1");
  
          {
              SQLException error = null;
              try {
                  stmt.getRowId(0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getRowId("0");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNString() throws Exception {
          stmt.setNString(1, (String) null);
          stmt.setNString("1", (String) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setNString("0", (String) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNString(0, (String) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_getObject() throws Exception {
          stmt.getObject(1, (java.util.Map) null);
          stmt.getObject("1", (java.util.Map) null);
  
          {
              SQLException error = null;
              try {
                  stmt.getObject(0, (java.util.Map) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.getObject("0", (java.util.Map) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBoolean() throws Exception {
          stmt.setBoolean(1, true);
          stmt.setBoolean("1", true);
  
          {
              SQLException error = null;
              try {
                  stmt.setBoolean("0", true);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setBoolean(0, true);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setURL() throws Exception {
          stmt.setURL(1, null);
          stmt.setURL("1", null);
  
          {
              SQLException error = null;
              try {
                  stmt.setURL("0", null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setURL(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNClob_2() throws Exception {
          stmt.setNClob(1, (NClob) null);
          stmt.setNClob("1", (NClob) null);
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob("0", (NClob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNClob(0, (NClob) null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNull_1() throws Exception {
          stmt.setNull(1, Types.INTEGER);
          stmt.setNull("1", Types.INTEGER);
  
          {
              SQLException error = null;
              try {
                  stmt.setNull("0", Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.setNull(0, Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_registerOutParameter() throws Exception {
          stmt.registerOutParameter(1, Types.INTEGER, "Int");
          stmt.registerOutParameter("1", Types.INTEGER, "Int");
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter("0", Types.INTEGER, "Int");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter(0, Types.INTEGER, "Int");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_registerOutParameter_1() throws Exception {
          stmt.registerOutParameter(1, Types.INTEGER, 2);
          stmt.registerOutParameter("1", Types.INTEGER, 2);
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter("0", Types.INTEGER, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter(0, Types.INTEGER, 2);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_registerOutParameter_2() throws Exception {
          stmt.registerOutParameter(1, Types.INTEGER);
          stmt.registerOutParameter("1", Types.INTEGER);
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter("0", Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
  
          {
              SQLException error = null;
              try {
                  stmt.registerOutParameter(0, Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  }
  