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.MockConnection;
  import com.alibaba.druid.mock.MockPreparedStatement;
  import com.alibaba.druid.pool.DruidConnectionHolder;
  import com.alibaba.druid.pool.DruidDataSource;
  import com.alibaba.druid.pool.DruidPooledConnection;
  import com.alibaba.druid.pool.DruidPooledPreparedStatement;
  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.math.BigDecimal;
  import java.sql.Date;
  import java.sql.SQLException;
  import java.sql.Timestamp;
  import java.sql.Types;
  import java.util.Arrays;
  
  public class PoolablePreparedStatementTest extends TestCase {
      protected MockPreparedStatement raw;
      protected DruidPooledPreparedStatement stmt;
  
      protected void setUp() throws Exception {
          DruidDataSource dataSource = new DruidDataSource();
          MockConnection mockConn = new MockConnection();
          DruidConnectionHolder connHolder = new DruidConnectionHolder(dataSource, mockConn, 0);
          DruidPooledConnection conn = new DruidPooledConnection(connHolder);
  
          raw = new MockPreparedStatement(null, null);
          stmt = new DruidPooledPreparedStatement(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);
              }
          };
      }
  
      protected void tearDown() throws Exception {
          stmt.clearParameters();
          assertEquals(0, raw.getParameters().size());
      }
  
      public void test_basic() throws Exception {
          assertEquals(raw, stmt.getRawPreparedStatement());
          assertEquals(raw, stmt.getRawStatement());
      }
  
      public void test_setBoolean() throws Exception {
          stmt.setBoolean(1, true);
  
          assertEquals(Boolean.TRUE, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setBoolean(0, true);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setNull() throws Exception {
          stmt.setNull(1, Types.INTEGER);
  
          assertEquals(null, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setNull(0, Types.INTEGER);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setByte() throws Exception {
          stmt.setByte(1, (byte) 23);
  
          assertEquals(new Byte((byte) 23), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setByte(0, Byte.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setShort() throws Exception {
          stmt.setShort(1, Short.MAX_VALUE);
  
          assertEquals(new Short(Short.MAX_VALUE), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setShort(0, Short.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setInt() throws Exception {
          stmt.setInt(1, Integer.MAX_VALUE);
  
          assertEquals(new Integer(Integer.MAX_VALUE), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setInt(0, Integer.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setLong() throws Exception {
          stmt.setLong(1, Long.MAX_VALUE);
  
          assertEquals(new Long(Long.MAX_VALUE), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setLong(0, Long.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setFloat() throws Exception {
          stmt.setFloat(1, Float.MAX_VALUE);
  
          assertEquals(new Float(Float.MAX_VALUE), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setFloat(0, Float.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setDouble() throws Exception {
          stmt.setDouble(1, Double.MAX_VALUE);
  
          assertEquals(new Double(Double.MAX_VALUE), raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setDouble(0, Double.MAX_VALUE);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBigDecimal() throws Exception {
          stmt.setBigDecimal(1, BigDecimal.TEN);
  
          assertEquals(BigDecimal.TEN, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setBigDecimal(0, BigDecimal.TEN);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setString() throws Exception {
          stmt.setString(1, "中国");
  
          assertEquals("中国", raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setString(0, "中国");
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBytes() throws Exception {
          byte[] bytes = "中国".getBytes();
          stmt.setBytes(1, bytes);
  
          assertEquals(true, Arrays.equals(bytes, (byte[]) raw.getParameters().get(0)));
  
          {
              SQLException error = null;
              try {
                  stmt.setBytes(0, bytes);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setDate() throws Exception {
          Date value = new Date(System.currentTimeMillis());
          stmt.setDate(1, value);
  
          assertEquals(value, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setDate(0, value);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setTimestamp() throws Exception {
          Timestamp value = new Timestamp(System.currentTimeMillis());
          stmt.setTimestamp(1, value);
  
          assertEquals(value, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setTimestamp(0, value);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setAsciiStream() throws Exception {
          InputStream value = null;
          stmt.setAsciiStream(1, value);
  
          assertEquals(value, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setAsciiStream(0, value);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      @SuppressWarnings("deprecation")
      public void test_setUnicodeStream() throws Exception {
          InputStream value = null;
          stmt.setUnicodeStream(1, value, 0);
  
          assertEquals(value, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setUnicodeStream(0, value, 0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setBinaryStream() throws Exception {
          InputStream value = null;
          stmt.setBinaryStream(1, value, 0);
  
          assertEquals(value, raw.getParameters().get(0));
  
          {
              SQLException error = null;
              try {
                  stmt.setBinaryStream(0, value, 0);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_updateCharacterStream_2() throws Exception {
          stmt.setCharacterStream(1, (Reader) null, 1L);
  
          {
              SQLException error = null;
              try {
                  stmt.setCharacterStream(0, (Reader) null, 1L);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setRef() throws Exception {
          stmt.setRef(1, null);
  
          {
              SQLException error = null;
              try {
                  stmt.setRef(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  
      public void test_setArray() throws Exception {
          stmt.setArray(1, null);
  
          {
              SQLException error = null;
              try {
                  stmt.setArray(0, null);
              } catch (SQLException ex) {
                  error = ex;
              }
              assertNotNull(error);
          }
      }
  }
  