From 2770b405a5f9b377ec6b0e3e34aef1184499bd88 Mon Sep 17 00:00:00 2001 From: wenshao Date: Fri, 16 Sep 2011 14:29:58 +0000 Subject: [PATCH] =?UTF-8?q?=E5=AE=8C=E5=96=84=E6=B5=8B=E8=AF=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit git-svn-id: http://code.alibabatech.com/svn/druid/trunk@821 b9813039-fb51-4c41-a8b9-e21c2acb5095 --- .../alibaba/druid/mock/MockConnection.java | 24 +- .../druid/pool/PoolableConnection.java | 2 +- .../druid/pool/PoolablePreparedStatement.java | 4 +- .../druid/bvt/pool/basic/ConnectionTest4.java | 495 ++++++++++++++++++ .../pool/basic/PreparedStatementKeyTest.java | 30 ++ 5 files changed, 550 insertions(+), 5 deletions(-) diff --git a/src/main/java/com/alibaba/druid/mock/MockConnection.java b/src/main/java/com/alibaba/druid/mock/MockConnection.java index 2c8b775162..c8d65b4305 100644 --- a/src/main/java/com/alibaba/druid/mock/MockConnection.java +++ b/src/main/java/com/alibaba/druid/mock/MockConnection.java @@ -152,6 +152,10 @@ public class MockConnection implements Connection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { + if (closed) { + throw new SQLException(); + } + this.autoCommit = autoCommit; } @@ -162,11 +166,17 @@ public class MockConnection implements Connection { @Override public void commit() throws SQLException { + if (closed) { + throw new SQLException(); + } } @Override public void rollback() throws SQLException { + if (closed) { + throw new SQLException(); + } } @@ -280,22 +290,32 @@ public class MockConnection implements Connection { @Override public Savepoint setSavepoint() throws SQLException { + if (closed) { + throw new SQLException(); + } return null; } @Override public Savepoint setSavepoint(String name) throws SQLException { + if (closed) { + throw new SQLException(); + } return null; } @Override public void rollback(Savepoint savepoint) throws SQLException { - + if (closed) { + throw new SQLException(); + } } @Override public void releaseSavepoint(Savepoint savepoint) throws SQLException { - + if (closed) { + throw new SQLException(); + } } @Override diff --git a/src/main/java/com/alibaba/druid/pool/PoolableConnection.java b/src/main/java/com/alibaba/druid/pool/PoolableConnection.java index 1ecf3ae69c..36be83d253 100644 --- a/src/main/java/com/alibaba/druid/pool/PoolableConnection.java +++ b/src/main/java/com/alibaba/druid/pool/PoolableConnection.java @@ -845,7 +845,7 @@ public class PoolableConnection implements PooledConnection, Connection { holder.getStatementEventListeners().remove(listener); } - protected void checkOpen() throws SQLException { + public void checkOpen() throws SQLException { if (holder == null) { throw new SQLException("connection is closed"); } diff --git a/src/main/java/com/alibaba/druid/pool/PoolablePreparedStatement.java b/src/main/java/com/alibaba/druid/pool/PoolablePreparedStatement.java index 20314d9995..cd427a07a1 100644 --- a/src/main/java/com/alibaba/druid/pool/PoolablePreparedStatement.java +++ b/src/main/java/com/alibaba/druid/pool/PoolablePreparedStatement.java @@ -699,9 +699,9 @@ public class PoolablePreparedStatement extends PoolableStatement implements Prep protected final MethodType methodType; - public PreparedStatementKey(String sql, String catalog, MethodType methodType){ + public PreparedStatementKey(String sql, String catalog, MethodType methodType) throws SQLException{ if (sql == null) { - throw new IllegalArgumentException("sql is null"); + throw new SQLException("sql is null"); } this.sql = sql; diff --git a/src/test/java/com/alibaba/druid/bvt/pool/basic/ConnectionTest4.java b/src/test/java/com/alibaba/druid/bvt/pool/basic/ConnectionTest4.java index 279ea5b4fc..829a302b35 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/basic/ConnectionTest4.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/basic/ConnectionTest4.java @@ -2,6 +2,7 @@ package com.alibaba.druid.bvt.pool.basic; import java.sql.Connection; import java.sql.Date; +import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; @@ -9,6 +10,7 @@ import junit.framework.Assert; import junit.framework.TestCase; import com.alibaba.druid.mock.MockDriver; +import com.alibaba.druid.mock.MockPreparedStatement; import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.pool.PoolableConnection; import com.alibaba.druid.stat.DruidDataSourceStatManager; @@ -56,12 +58,19 @@ public class ConnectionTest4 extends TestCase { PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); Assert.assertEquals(null, conn.unwrap(Date.class)); + Assert.assertEquals(null, conn.unwrap(null)); Assert.assertEquals(conn, conn.unwrap(Connection.class)); + Assert.assertEquals(false, conn.isWrapperFor(null)); Assert.assertEquals(true, conn.isWrapperFor(PoolableConnection.class)); Assert.assertEquals(true, conn.isWrapperFor(Connection.class)); + + Assert.assertEquals("SELECT 1", conn.nativeSQL("SELECT 1")); + conn.toString(); + conn.close(); + conn.toString(); } public void test_prepareStatement_error() throws Exception { @@ -118,4 +127,490 @@ public class ConnectionTest4 extends TestCase { conn.close(); } + + public void test_prepareStatement_error4() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + { + SQLException error = null; + try { + conn.prepareStatement(null, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, + ResultSet.HOLD_CURSORS_OVER_COMMIT); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepareStatement_error5() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + { + SQLException error = null; + try { + conn.prepareStatement(null, new int[0]); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepareStatement_error6() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareStatement("SELECT 1", new int[0]); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepareStatement_error7() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareStatement("SELECT 1", new String[0]); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepareStatement_error8() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareStatement("SELECT 1", 0); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepareStatement() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_prepareStatement_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY, + ResultSet.HOLD_CURSORS_OVER_COMMIT); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY, + ResultSet.HOLD_CURSORS_OVER_COMMIT); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_prepareStatement_2() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", new int[0]); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", new int[0]); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_prepareStatement_3() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", new String[0]); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", new String[0]); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_prepareStatement_4() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", 0); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareStatement("SELECT 1", 0); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_preCall_error() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, + ResultSet.HOLD_CURSORS_OVER_COMMIT); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_preCall_error_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_preCall_error_2() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.prepareCall("SELECT 1"); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_prepCall() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY, ResultSet.HOLD_CURSORS_OVER_COMMIT); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_prepCall_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + MockPreparedStatement raw = null; + { + PreparedStatement stmt = conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY); + raw = stmt.unwrap(MockPreparedStatement.class); + stmt.close(); + } + { + PreparedStatement stmt = conn.prepareCall("SELECT 1", ResultSet.TYPE_FORWARD_ONLY, + ResultSet.CONCUR_READ_ONLY); + Assert.assertEquals(raw, stmt.unwrap(MockPreparedStatement.class)); + stmt.close(); + } + + conn.close(); + } + + public void test_create() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.createStatement(); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_create_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY, + ResultSet.HOLD_CURSORS_OVER_COMMIT); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_create_2() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_setAutoCommit() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getAutoCommit(); + conn.setAutoCommit(true); + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.setAutoCommit(false); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_commit() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.commit(); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_rollback() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.rollback(); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_rollback_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.rollback(null); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_releaseSavepoint_1() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.getConnection().close(); + { + SQLException error = null; + try { + conn.releaseSavepoint(null); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + + conn.close(); + } + + public void test_addListenerError() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.close(); + { + Exception error = null; + try { + conn.addConnectionEventListener(null); + } catch (IllegalStateException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_addListenerError2() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.close(); + { + Exception error = null; + try { + conn.addStatementEventListener(null); + } catch (IllegalStateException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_removeConnectionEventListener() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.close(); + { + Exception error = null; + try { + conn.removeConnectionEventListener(null); + } catch (IllegalStateException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_removeStatementEventListener() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.close(); + { + Exception error = null; + try { + conn.removeStatementEventListener(null); + } catch (IllegalStateException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } + + public void test_checkOpen_error() throws Exception { + PoolableConnection conn = dataSource.getConnection().unwrap(PoolableConnection.class); + + conn.close(); + { + Exception error = null; + try { + conn.checkOpen(); + } catch (SQLException ex) { + error = ex; + } + Assert.assertNotNull(error); + } + } } diff --git a/src/test/java/com/alibaba/druid/bvt/pool/basic/PreparedStatementKeyTest.java b/src/test/java/com/alibaba/druid/bvt/pool/basic/PreparedStatementKeyTest.java index 2c675060d0..f44313dfcf 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/basic/PreparedStatementKeyTest.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/basic/PreparedStatementKeyTest.java @@ -63,6 +63,36 @@ public class PreparedStatementKeyTest extends TestCase { Assert.assertFalse(k3.equals(k1)); } + public void test_equals_5() throws Exception { + PreparedStatementKey k1 = new PreparedStatementKey("x1", null, MethodType.M1); + PreparedStatementKey k2 = new PreparedStatementKey("x1", null, MethodType.M2); + PreparedStatementKey k3 = new PreparedStatementKey("x1", null, MethodType.M3); + + k1.hashCode(); + + Assert.assertFalse(k1.equals(k2)); + Assert.assertFalse(k1.equals(k3)); + Assert.assertFalse(k2.equals(k1)); + Assert.assertFalse(k2.equals(k3)); + Assert.assertFalse(k3.equals(k2)); + Assert.assertFalse(k3.equals(k1)); + } + + public void test_equals_6() throws Exception { + PreparedStatementKey k1 = new PreparedStatementKey("x1", null, MethodType.M1); + PreparedStatementKey k2 = new PreparedStatementKey("x2", null, MethodType.M1); + PreparedStatementKey k3 = new PreparedStatementKey("x3", null, MethodType.M1); + + k1.hashCode(); + + Assert.assertFalse(k1.equals(k2)); + Assert.assertFalse(k1.equals(k3)); + Assert.assertFalse(k2.equals(k1)); + Assert.assertFalse(k2.equals(k3)); + Assert.assertFalse(k3.equals(k2)); + Assert.assertFalse(k3.equals(k1)); + } + public void test_contains() throws Exception { PreparedStatementKey k1 = new PreparedStatementKey("x1", "c1", MethodType.M1); PreparedStatementPool pool = new PreparedStatementPool();