From 2f457d78f84954246560f51c6ecc25c98ef43229 Mon Sep 17 00:00:00 2001 From: wenshao Date: Wed, 1 May 2013 13:37:21 +0800 Subject: [PATCH] add exection sorter test --- .../com/alibaba/druid/mock/MockStatement.java | 4 +- .../alibaba/druid/pool/DataSourceAdapter.java | 68 --------------- .../druid/pool/DataSourceClosedException.java | 8 -- .../alibaba/druid/pool/DruidDataSource.java | 43 ++++----- .../druid/pool/DruidPooledConnection.java | 16 ---- .../pool/GetConnectionTimeoutException.java | 2 +- .../statement/SQLCreateIndexStatement.java | 10 ++- .../ast/statement/SQLDropIndexStatement.java | 12 ++- .../druid/wall/spi/WallVisitorUtils.java | 16 +++- .../druid/bvt/filter/wall/CountTest.java | 3 +- .../bvt/filter/wall/MySqlWallTest84.java | 43 +++++++++ .../bvt/filter/wall/MySqlWallTest85.java | 43 +++++++++ .../bvt/filter/wall/MySqlWallTest86.java | 44 ++++++++++ .../bvt/filter/wall/MySqlWallTest87.java | 44 ++++++++++ .../bvt/filter/wall/MySqlWallTest88.java | 44 ++++++++++ .../exception/OracleExceptionSorterTest.java | 12 +-- .../OracleExceptionSorterTest_closeStmt.java | 8 +- .../OracleExceptionSorterTest_setCatalog.java | 1 - ...OracleExceptionSorterTest_setReadOnly.java | 1 - ...racleExceptionSorterTest_setSavepoint.java | 1 - ...eptionSorterTest_setSavepointWithName.java | 1 - ...acleExceptionSorterTest_stmt_addBatch.java | 85 ++++++++++++++++++ ...OracleExceptionSorterTest_stmt_cancel.java | 86 ++++++++++++++++++ ...leExceptionSorterTest_stmt_clearBatch.java | 86 ++++++++++++++++++ ...ceptionSorterTest_stmt_clearWarrnings.java | 86 ++++++++++++++++++ ...racleExceptionSorterTest_stmt_execute.java | 85 ++++++++++++++++++ ...ExceptionSorterTest_stmt_executeBatch.java | 86 ++++++++++++++++++ ...ExceptionSorterTest_stmt_executeQuery.java | 85 ++++++++++++++++++ ...xceptionSorterTest_stmt_executeUpdate.java | 85 ++++++++++++++++++ ...eptionSorterTest_stmt_executeUpdate_1.java | 85 ++++++++++++++++++ ...eptionSorterTest_stmt_executeUpdate_2.java | 85 ++++++++++++++++++ ...eptionSorterTest_stmt_executeUpdate_3.java | 85 ++++++++++++++++++ ...cleExceptionSorterTest_stmt_execute_1.java | 85 ++++++++++++++++++ ...cleExceptionSorterTest_stmt_execute_2.java | 85 ++++++++++++++++++ ...cleExceptionSorterTest_stmt_execute_3.java | 85 ++++++++++++++++++ ...tionSorterTest_stmt_getFetchDirection.java | 85 ++++++++++++++++++ ...ExceptionSorterTest_stmt_getFetchSize.java | 85 ++++++++++++++++++ ...ptionSorterTest_stmt_getGeneratedKeys.java | 85 ++++++++++++++++++ ...eExceptionSorterTest_stmt_getMaxField.java | 85 ++++++++++++++++++ ...leExceptionSorterTest_stmt_getMaxRows.java | 85 ++++++++++++++++++ ...ceptionSorterTest_stmt_getMoreResults.java | 86 ++++++++++++++++++ ...ptionSorterTest_stmt_getMoreResults_1.java | 85 ++++++++++++++++++ ...eptionSorterTest_stmt_getQueryTimeout.java | 85 ++++++++++++++++++ ...ExceptionSorterTest_stmt_getResultSet.java | 86 ++++++++++++++++++ ...rterTest_stmt_getResultSetConcurrency.java | 85 ++++++++++++++++++ ...rterTest_stmt_getResultSetHoldability.java | 85 ++++++++++++++++++ ...ptionSorterTest_stmt_getResultSetType.java | 85 ++++++++++++++++++ ...ceptionSorterTest_stmt_getUpdateCount.java | 86 ++++++++++++++++++ ...ExceptionSorterTest_stmt_getWarrnings.java | 86 ++++++++++++++++++ ...xceptionSorterTest_stmt_setCursorName.java | 85 ++++++++++++++++++ ...onSorterTest_stmt_setEscapeProcessing.java | 85 ++++++++++++++++++ ...tionSorterTest_stmt_setFetchDirection.java | 87 +++++++++++++++++++ ...ExceptionSorterTest_stmt_setFetchSize.java | 85 ++++++++++++++++++ ...eExceptionSorterTest_stmt_setMaxField.java | 85 ++++++++++++++++++ ...leExceptionSorterTest_stmt_setMaxRows.java | 85 ++++++++++++++++++ ...eptionSorterTest_stmt_setQueryTimeout.java | 85 ++++++++++++++++++ .../pool/property/PropertyTest_filters.java | 33 +++++++ .../property/PropertyTest_testOnBorrow.java | 32 +++++++ .../property/PropertyTest_testWhileIdle.java | 30 +++++++ .../PropertyTest_useGloalDataSourceStat.java | 30 +++++++ .../PropertyTest_validationQuery.java | 24 +++++ 61 files changed, 3417 insertions(+), 141 deletions(-) delete mode 100644 src/main/java/com/alibaba/druid/pool/DataSourceAdapter.java create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest84.java create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest85.java create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest86.java create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest87.java create mode 100644 src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest88.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_addBatch.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_cancel.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearBatch.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearWarrnings.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeBatch.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeQuery.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_1.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_2.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_3.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_1.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_2.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_3.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchDirection.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchSize.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getGeneratedKeys.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxField.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxRows.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults_1.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getQueryTimeout.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSet.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetConcurrency.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetHoldability.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetType.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getUpdateCount.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getWarrnings.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setCursorName.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setEscapeProcessing.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchDirection.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchSize.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxField.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxRows.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setQueryTimeout.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_filters.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testOnBorrow.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testWhileIdle.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_useGloalDataSourceStat.java create mode 100644 src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_validationQuery.java diff --git a/src/main/java/com/alibaba/druid/mock/MockStatement.java b/src/main/java/com/alibaba/druid/mock/MockStatement.java index 18001a5431..650614a2d0 100644 --- a/src/main/java/com/alibaba/druid/mock/MockStatement.java +++ b/src/main/java/com/alibaba/druid/mock/MockStatement.java @@ -41,8 +41,8 @@ public class MockStatement extends StatementBase implements MockStatementBase, S throw new SQLException(); } - if (this.mockConnection != null && this.mockConnection.isClosed()) { - throw new MockConnectionClosedException(); + if (this.mockConnection != null) { + mockConnection.checkState(); } } diff --git a/src/main/java/com/alibaba/druid/pool/DataSourceAdapter.java b/src/main/java/com/alibaba/druid/pool/DataSourceAdapter.java deleted file mode 100644 index ee7928d948..0000000000 --- a/src/main/java/com/alibaba/druid/pool/DataSourceAdapter.java +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright 1999-2011 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.pool; - -import java.io.PrintWriter; -import java.sql.Connection; -import java.sql.SQLException; -import java.sql.SQLFeatureNotSupportedException; -import java.util.logging.Logger; - -import javax.sql.DataSource; - -public class DataSourceAdapter extends WrapperAdapter implements DataSource { - - private int loginTimeout = 0; - private PrintWriter logWriter = new PrintWriter(System.out); - - public DataSourceAdapter(){ - } - - @Override - public PrintWriter getLogWriter() throws SQLException { - return logWriter; - } - - @Override - public void setLogWriter(PrintWriter out) throws SQLException { - this.logWriter = out; - } - - @Override - public void setLoginTimeout(int seconds) throws SQLException { - loginTimeout = seconds; - } - - @Override - public int getLoginTimeout() throws SQLException { - return loginTimeout; - } - - @Override - public Connection getConnection() throws SQLException { - throw new UnsupportedOperationException(); - } - - @Override - public Connection getConnection(String username, String password) throws SQLException { - throw new UnsupportedOperationException(); - } - - public Logger getParentLogger() throws SQLFeatureNotSupportedException { - throw new SQLFeatureNotSupportedException(); - } - -} diff --git a/src/main/java/com/alibaba/druid/pool/DataSourceClosedException.java b/src/main/java/com/alibaba/druid/pool/DataSourceClosedException.java index 0d462d14cd..e965da4b21 100644 --- a/src/main/java/com/alibaba/druid/pool/DataSourceClosedException.java +++ b/src/main/java/com/alibaba/druid/pool/DataSourceClosedException.java @@ -21,16 +21,8 @@ public class DataSourceClosedException extends SQLException { private static final long serialVersionUID = 1L; - public DataSourceClosedException(){ - super(); - } - public DataSourceClosedException(String reason){ super(reason); } - public DataSourceClosedException(Throwable cause){ - super(cause); - } - } diff --git a/src/main/java/com/alibaba/druid/pool/DruidDataSource.java b/src/main/java/com/alibaba/druid/pool/DruidDataSource.java index 2528da7610..d0c64df731 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidDataSource.java +++ b/src/main/java/com/alibaba/druid/pool/DruidDataSource.java @@ -143,6 +143,16 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat String property = System.getProperty("druid.testWhileIdle"); if ("true".equals(property)) { this.setTestWhileIdle(true); + } else if ("false".equals(property)) { + this.setTestWhileIdle(false); + } + } + { + String property = System.getProperty("druid.testOnBorrow"); + if ("true".equals(property)) { + this.setTestOnBorrow(true); + } else if ("false".equals(property)) { + this.setTestOnBorrow(false); } } { @@ -159,6 +169,19 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat this.setUseGloalDataSourceStat(false); } } + { + String property = System.getProperty("druid.filters"); + + if (property == null || property.length() == 0) { + return; + } + + try { + this.setFilters(property); + } catch (SQLException e) { + LOG.error("setFilters error", e); + } + } } public boolean isUseGloalDataSourceStat() { @@ -374,8 +397,6 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat this.id = DruidDriver.createDataSourceId(); - loadFilterFromSystemProperty(); - if (this.dbType == null || this.dbType.length() == 0) { this.dbType = JdbcUtils.getDbType(jdbcUrl, null); } @@ -523,15 +544,6 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat createConnectionThread.start(); } - private void loadFilterFromSystemProperty() throws SQLException { - String property = System.getProperty("druid.filters"); - - if (property == null || property.length() == 0) { - return; - } - - this.setFilters(property); - } /** * load filters from SPI ServiceLoader @@ -1284,15 +1296,6 @@ public class DruidDataSource extends DruidAbstractDataSource implements DruidDat } } - public boolean isBusy() { - lock.lock(); - try { - return this.inited && this.activeCount == maxActive && this.poolingCount == 0; - } finally { - lock.unlock(); - } - } - public long getRemoveAbandonedCount() { return removeAbandonedCount; } diff --git a/src/main/java/com/alibaba/druid/pool/DruidPooledConnection.java b/src/main/java/com/alibaba/druid/pool/DruidPooledConnection.java index 013b732d07..1a858d93e7 100644 --- a/src/main/java/com/alibaba/druid/pool/DruidPooledConnection.java +++ b/src/main/java/com/alibaba/druid/pool/DruidPooledConnection.java @@ -203,22 +203,6 @@ public class DruidPooledConnection extends PoolableWrapper implements javax.sql. return disable; } - public void discard() { - if (this.disable) { - return; - } - - DruidConnectionHolder holder = this.holder; - if (holder == null) { - if (dupCloseLogEnable) { - LOG.error("dup close"); - } - return; - } - - holder.getDataSource().discardConnection(holder.getConnection()); - } - @Override public void close() throws SQLException { if (this.disable) { diff --git a/src/main/java/com/alibaba/druid/pool/GetConnectionTimeoutException.java b/src/main/java/com/alibaba/druid/pool/GetConnectionTimeoutException.java index 6ec8769a02..e40b0c2cc2 100644 --- a/src/main/java/com/alibaba/druid/pool/GetConnectionTimeoutException.java +++ b/src/main/java/com/alibaba/druid/pool/GetConnectionTimeoutException.java @@ -20,7 +20,7 @@ import java.sql.SQLException; public class GetConnectionTimeoutException extends SQLException { private static final long serialVersionUID = 1L; - + public GetConnectionTimeoutException(){ super(); } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateIndexStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateIndexStatement.java index 222acdc0c4..c5969c5ada 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateIndexStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLCreateIndexStatement.java @@ -30,17 +30,21 @@ public class SQLCreateIndexStatement extends SQLStatementImpl implements SQLDDLS private SQLName name; - private SQLName table; + private SQLTableSource table; private List items = new ArrayList(); private String type; - public SQLName getTable() { + public SQLTableSource getTable() { return table; } - + public void setTable(SQLName table) { + this.setTable(new SQLExprTableSource(table)); + } + + public void setTable(SQLTableSource table) { this.table = table; } diff --git a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLDropIndexStatement.java b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLDropIndexStatement.java index 407ddfadda..01dcd91c4f 100644 --- a/src/main/java/com/alibaba/druid/sql/ast/statement/SQLDropIndexStatement.java +++ b/src/main/java/com/alibaba/druid/sql/ast/statement/SQLDropIndexStatement.java @@ -21,10 +21,10 @@ import com.alibaba.druid.sql.visitor.SQLASTVisitor; public class SQLDropIndexStatement extends SQLStatementImpl implements SQLDDLStatement { - private static final long serialVersionUID = 1L; + private static final long serialVersionUID = 1L; - private SQLExpr indexName; - private SQLExpr tableName; + private SQLExpr indexName; + private SQLExprTableSource tableName; public SQLExpr getIndexName() { return indexName; @@ -34,11 +34,15 @@ public class SQLDropIndexStatement extends SQLStatementImpl implements SQLDDLSta this.indexName = indexName; } - public SQLExpr getTableName() { + public SQLExprTableSource getTableName() { return tableName; } public void setTableName(SQLExpr tableName) { + this.setTableName(new SQLExprTableSource(tableName)); + } + + public void setTableName(SQLExprTableSource tableName) { this.tableName = tableName; } diff --git a/src/main/java/com/alibaba/druid/wall/spi/WallVisitorUtils.java b/src/main/java/com/alibaba/druid/wall/spi/WallVisitorUtils.java index aa318f448b..3b2169d9c1 100644 --- a/src/main/java/com/alibaba/druid/wall/spi/WallVisitorUtils.java +++ b/src/main/java/com/alibaba/druid/wall/spi/WallVisitorUtils.java @@ -47,9 +47,13 @@ import com.alibaba.druid.sql.ast.expr.SQLPropertyExpr; import com.alibaba.druid.sql.ast.expr.SQLQueryExpr; import com.alibaba.druid.sql.ast.statement.SQLAlterTableStatement; import com.alibaba.druid.sql.ast.statement.SQLCallStatement; +import com.alibaba.druid.sql.ast.statement.SQLCreateIndexStatement; import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement; +import com.alibaba.druid.sql.ast.statement.SQLCreateViewStatement; import com.alibaba.druid.sql.ast.statement.SQLDeleteStatement; +import com.alibaba.druid.sql.ast.statement.SQLDropIndexStatement; import com.alibaba.druid.sql.ast.statement.SQLDropTableStatement; +import com.alibaba.druid.sql.ast.statement.SQLDropViewStatement; import com.alibaba.druid.sql.ast.statement.SQLExprTableSource; import com.alibaba.druid.sql.ast.statement.SQLInsertInto; import com.alibaba.druid.sql.ast.statement.SQLInsertStatement; @@ -1180,11 +1184,11 @@ public class WallVisitorUtils { if (name.startsWith("\"") && name.endsWith("\"")) { name = name.substring(1, name.length() - 1); } - + if (name.startsWith("'") && name.endsWith("'")) { name = name.substring(1, name.length() - 1); } - + if (name.startsWith("`") && name.endsWith("`")) { name = name.substring(1, name.length() - 1); } @@ -1293,7 +1297,9 @@ public class WallVisitorUtils { allow = config.isTruncateAllow(); denyMessage = "truncate not allow"; errorCode = ErrorCode.TRUNCATE_NOT_ALLOW; - } else if (x instanceof SQLCreateTableStatement) { + } else if (x instanceof SQLCreateTableStatement // + || x instanceof SQLCreateIndexStatement // + || x instanceof SQLCreateViewStatement) { allow = config.isCreateTableAllow(); denyMessage = "create table not allow"; errorCode = ErrorCode.CREATE_TABLE_NOT_ALLOW; @@ -1301,7 +1307,9 @@ public class WallVisitorUtils { allow = config.isAlterTableAllow(); denyMessage = "alter table not allow"; errorCode = ErrorCode.ALTER_TABLE_NOT_ALLOW; - } else if (x instanceof SQLDropTableStatement) { + } else if (x instanceof SQLDropTableStatement // + || x instanceof SQLDropIndexStatement // + || x instanceof SQLDropViewStatement) { allow = config.isDropTableAllow(); denyMessage = "drop table not allow"; errorCode = ErrorCode.DROP_TABLE_NOT_ALLOW; diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/CountTest.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/CountTest.java index f5bb75ec34..dc2ba4584b 100644 --- a/src/test/java/com/alibaba/druid/bvt/filter/wall/CountTest.java +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/CountTest.java @@ -15,9 +15,10 @@ */ package com.alibaba.druid.bvt.filter.wall; -import junit.framework.Assert; import junit.framework.TestCase; +import org.junit.Assert; + import com.alibaba.druid.sql.SQLUtils; import com.alibaba.druid.wall.spi.WallVisitorUtils; diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest84.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest84.java new file mode 100644 index 0000000000..a0a3842571 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest84.java @@ -0,0 +1,43 @@ +/* + * Copyright 1999-2011 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.filter.wall; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; + +/** + * SQLServerWallTest + * + * @author RaymondXiu + * @version 1.0, 2012-3-18 + * @see + */ +public class MySqlWallTest84 extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + Assert.assertTrue(provider.checkValid(// + "CREATE INDEX part_of_name ON customer (name(10));")); + + Assert.assertEquals(1, provider.getTableStats().size()); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest85.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest85.java new file mode 100644 index 0000000000..0c70372800 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest85.java @@ -0,0 +1,43 @@ +/* + * Copyright 1999-2011 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.filter.wall; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; + +/** + * SQLServerWallTest + * + * @author RaymondXiu + * @version 1.0, 2012-3-18 + * @see + */ +public class MySqlWallTest85 extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + Assert.assertTrue(provider.checkValid(// + "CREATE TABLE lookup (id INT) ENGINE = MEMORY;")); + + Assert.assertEquals(1, provider.getTableStats().size()); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest86.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest86.java new file mode 100644 index 0000000000..c9b7c34e0c --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest86.java @@ -0,0 +1,44 @@ +/* + * Copyright 1999-2011 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.filter.wall; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; + +/** + * SQLServerWallTest + * + * @author RaymondXiu + * @version 1.0, 2012-3-18 + * @see + */ +public class MySqlWallTest86 extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + Assert.assertTrue(provider.checkValid(// + "CREATE INDEX id_index ON lookup (id) USING BTREE;")); + + Assert.assertEquals(1, provider.getTableStats().size()); + Assert.assertTrue(provider.getTableStats().containsKey("lookup")); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest87.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest87.java new file mode 100644 index 0000000000..14e1bdbc2f --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest87.java @@ -0,0 +1,44 @@ +/* + * Copyright 1999-2011 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.filter.wall; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; + +/** + * SQLServerWallTest + * + * @author RaymondXiu + * @version 1.0, 2012-3-18 + * @see + */ +public class MySqlWallTest87 extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + Assert.assertTrue(provider.checkValid(// + "CREATE VIEW test.v AS SELECT * FROM t;")); + + Assert.assertEquals(1, provider.getTableStats().size()); + Assert.assertTrue(provider.getTableStats().containsKey("t")); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest88.java b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest88.java new file mode 100644 index 0000000000..aa99ae6b9d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/filter/wall/MySqlWallTest88.java @@ -0,0 +1,44 @@ +/* + * Copyright 1999-2011 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.filter.wall; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.wall.WallProvider; +import com.alibaba.druid.wall.spi.MySqlWallProvider; + +/** + * SQLServerWallTest + * + * @author RaymondXiu + * @version 1.0, 2012-3-18 + * @see + */ +public class MySqlWallTest88 extends TestCase { + + public void test_false() throws Exception { + WallProvider provider = new MySqlWallProvider(); + + Assert.assertTrue(provider.checkValid(// + "DROP INDEX `PRIMARY` ON t;")); + + Assert.assertEquals(1, provider.getTableStats().size()); + Assert.assertTrue(provider.getTableStats().containsKey("t")); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest.java index 3a66936aeb..659870ce92 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest.java @@ -3,10 +3,10 @@ package com.alibaba.druid.bvt.pool.exception; import java.sql.PreparedStatement; import java.sql.SQLException; -import org.junit.Assert; - import junit.framework.TestCase; +import org.junit.Assert; + import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.pool.DruidPooledConnection; import com.alibaba.druid.pool.vendor.OracleExceptionSorter; @@ -63,15 +63,15 @@ public class OracleExceptionSorterTest extends TestCase { pstmt.close(); - SQLException commetError = null; + SQLException commitError = null; try { conn.commit(); } catch (SQLException ex) { - commetError = ex; + commitError = ex; } - Assert.assertNotNull(commetError); - Assert.assertSame(exception, commetError.getCause()); + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); conn.close(); } diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_closeStmt.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_closeStmt.java index 7e707d3bc3..95df717c6b 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_closeStmt.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_closeStmt.java @@ -69,15 +69,15 @@ public class OracleExceptionSorterTest_closeStmt extends TestCase { Assert.assertNotNull(closedErrror); Assert.assertSame(exception, closedErrror); - SQLException commetError = null; + SQLException commitError = null; try { conn.commit(); } catch (SQLException ex) { - commetError = ex; + commitError = ex; } - Assert.assertNotNull(commetError); - Assert.assertSame(exception, commetError.getCause()); + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); conn.close(); } diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setCatalog.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setCatalog.java index a4a49d39b4..0d3d816e43 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setCatalog.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setCatalog.java @@ -2,7 +2,6 @@ package com.alibaba.druid.bvt.pool.exception; import java.sql.Connection; import java.sql.PreparedStatement; -import java.sql.ResultSet; import java.sql.SQLException; import junit.framework.TestCase; diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setReadOnly.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setReadOnly.java index d2a41ca017..9877e9393c 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setReadOnly.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setReadOnly.java @@ -2,7 +2,6 @@ package com.alibaba.druid.bvt.pool.exception; import java.sql.Connection; import java.sql.PreparedStatement; -import java.sql.ResultSet; import java.sql.SQLException; import junit.framework.TestCase; diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepoint.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepoint.java index fd6f4e424d..83ebf37950 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepoint.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepoint.java @@ -2,7 +2,6 @@ package com.alibaba.druid.bvt.pool.exception; import java.sql.Connection; import java.sql.PreparedStatement; -import java.sql.ResultSet; import java.sql.SQLException; import junit.framework.TestCase; diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepointWithName.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepointWithName.java index 779fb49430..1a2c655acc 100644 --- a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepointWithName.java +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_setSavepointWithName.java @@ -2,7 +2,6 @@ package com.alibaba.druid.bvt.pool.exception; import java.sql.Connection; import java.sql.PreparedStatement; -import java.sql.ResultSet; import java.sql.SQLException; import junit.framework.TestCase; diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_addBatch.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_addBatch.java new file mode 100644 index 0000000000..d28dd6f0fb --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_addBatch.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_addBatch extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.addBatch(sql); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_cancel.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_cancel.java new file mode 100644 index 0000000000..bc71a8150d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_cancel.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_cancel extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.cancel(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearBatch.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearBatch.java new file mode 100644 index 0000000000..6aaa9c187d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearBatch.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_clearBatch extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.addBatch(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.clearBatch(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearWarrnings.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearWarrnings.java new file mode 100644 index 0000000000..78038fb40f --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_clearWarrnings.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_clearWarrnings extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.clearWarnings(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute.java new file mode 100644 index 0000000000..2ea93d3ee0 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_execute extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.execute(sql); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeBatch.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeBatch.java new file mode 100644 index 0000000000..ec7b408cfe --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeBatch.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeBatch extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.addBatch(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.executeBatch(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeQuery.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeQuery.java new file mode 100644 index 0000000000..ea0009dd86 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeQuery.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeQuery extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.executeQuery(sql); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate.java new file mode 100644 index 0000000000..cc9eb6191b --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeUpdate extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.executeUpdate(sql); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_1.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_1.java new file mode 100644 index 0000000000..6b357493f2 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_1.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeUpdate_1 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.executeUpdate(sql, Statement.RETURN_GENERATED_KEYS); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_2.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_2.java new file mode 100644 index 0000000000..cb0fe7d87f --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_2.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeUpdate_2 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.executeUpdate(sql, new int[0]); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_3.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_3.java new file mode 100644 index 0000000000..e901f085a4 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_executeUpdate_3.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_executeUpdate_3 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.executeUpdate(sql, new String[0]); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_1.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_1.java new file mode 100644 index 0000000000..d0f05e39a2 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_1.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_execute_1 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.execute(sql, Statement.RETURN_GENERATED_KEYS); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_2.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_2.java new file mode 100644 index 0000000000..4a6c7f946d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_2.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_execute_2 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.execute(sql, new int[0]); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_3.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_3.java new file mode 100644 index 0000000000..7c28cf2ed2 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_execute_3.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_execute_3 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException execErrror = null; + try { + stmt.execute(sql, new String[0]); + } catch (SQLException ex) { + execErrror = ex; + } + Assert.assertNotNull(execErrror); + Assert.assertSame(exception, execErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchDirection.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchDirection.java new file mode 100644 index 0000000000..932b425e5c --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchDirection.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getFetchDirection extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getFetchDirection(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchSize.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchSize.java new file mode 100644 index 0000000000..4b0deb67a7 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getFetchSize.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getFetchSize extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getFetchSize(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getGeneratedKeys.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getGeneratedKeys.java new file mode 100644 index 0000000000..603d2c591e --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getGeneratedKeys.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getGeneratedKeys extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getMaxRows(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxField.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxField.java new file mode 100644 index 0000000000..bb3cd4a89b --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxField.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getMaxField extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getMaxFieldSize(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxRows.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxRows.java new file mode 100644 index 0000000000..ed4c8ecec0 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMaxRows.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getMaxRows extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getMaxRows(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults.java new file mode 100644 index 0000000000..995570b2f8 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getMoreResults extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getMoreResults(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults_1.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults_1.java new file mode 100644 index 0000000000..7474a7472d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getMoreResults_1.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getMoreResults_1 extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getMoreResults(1); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getQueryTimeout.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getQueryTimeout.java new file mode 100644 index 0000000000..14d17fcc45 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getQueryTimeout.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getQueryTimeout extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getQueryTimeout(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSet.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSet.java new file mode 100644 index 0000000000..cb17727e4e --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSet.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getResultSet extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getResultSet(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetConcurrency.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetConcurrency.java new file mode 100644 index 0000000000..45856e88ea --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetConcurrency.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getResultSetConcurrency extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getResultSetConcurrency(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetHoldability.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetHoldability.java new file mode 100644 index 0000000000..7708ba66ee --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetHoldability.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getResultSetHoldability extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getResultSetHoldability(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetType.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetType.java new file mode 100644 index 0000000000..ad2899f8d9 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getResultSetType.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getResultSetType extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getResultSetType(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getUpdateCount.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getUpdateCount.java new file mode 100644 index 0000000000..56271f5e8f --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getUpdateCount.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getUpdateCount extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getUpdateCount(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getWarrnings.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getWarrnings.java new file mode 100644 index 0000000000..8feb7c0545 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_getWarrnings.java @@ -0,0 +1,86 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_getWarrnings extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + stmt.execute(sql); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.getWarnings(); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setCursorName.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setCursorName.java new file mode 100644 index 0000000000..731458d8e8 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setCursorName.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setCursorName extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setCursorName("mycur"); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setEscapeProcessing.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setEscapeProcessing.java new file mode 100644 index 0000000000..5534e6e413 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setEscapeProcessing.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setEscapeProcessing extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setEscapeProcessing(true); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchDirection.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchDirection.java new file mode 100644 index 0000000000..f9ba2f65e6 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchDirection.java @@ -0,0 +1,87 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import javax.resource.cci.ResultSet; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setFetchDirection extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setFetchDirection(ResultSet.FETCH_FORWARD); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchSize.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchSize.java new file mode 100644 index 0000000000..0b1254f147 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setFetchSize.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setFetchSize extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setFetchSize(10); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxField.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxField.java new file mode 100644 index 0000000000..df1ed4e63f --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxField.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setMaxField extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setMaxFieldSize(10); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxRows.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxRows.java new file mode 100644 index 0000000000..b540338d18 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setMaxRows.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setMaxRows extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setMaxRows(10); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setQueryTimeout.java b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setQueryTimeout.java new file mode 100644 index 0000000000..81a5734016 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/exception/OracleExceptionSorterTest_stmt_setQueryTimeout.java @@ -0,0 +1,85 @@ +package com.alibaba.druid.bvt.pool.exception; + +import java.sql.PreparedStatement; +import java.sql.SQLException; +import java.sql.Statement; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.mock.MockConnection; +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.pool.DruidPooledConnection; +import com.alibaba.druid.pool.vendor.OracleExceptionSorter; +import com.alibaba.druid.stat.DruidDataSourceStatManager; +import com.alibaba.druid.stat.JdbcStatManager; +import com.alibaba.druid.test.util.OracleMockDriver; +import com.alibaba.druid.util.JdbcUtils; + +public class OracleExceptionSorterTest_stmt_setQueryTimeout extends TestCase { + + private DruidDataSource dataSource; + + protected void setUp() throws Exception { + Assert.assertEquals(0, JdbcStatManager.getInstance().getSqlList().size()); + + dataSource = new DruidDataSource(); + + dataSource.setExceptionSorter(new OracleExceptionSorter()); + + dataSource.setDriver(new OracleMockDriver()); + dataSource.setUrl("jdbc:mock:xxx"); + dataSource.setPoolPreparedStatements(true); + dataSource.setMaxOpenPreparedStatements(100); + } + + @Override + protected void tearDown() throws Exception { + JdbcUtils.close(dataSource); + Assert.assertEquals(0, DruidDataSourceStatManager.getInstance().getDataSourceList().size()); + } + + public void test_connect() throws Exception { + String sql = "SELECT 1"; + { + DruidPooledConnection conn = dataSource.getConnection(); + + PreparedStatement pstmt = conn.prepareStatement(sql); + pstmt.execute(); + pstmt.close(); + conn.close(); + } + + DruidPooledConnection conn = dataSource.getConnection(); + MockConnection mockConn = conn.unwrap(MockConnection.class); + Assert.assertNotNull(mockConn); + + Statement stmt = conn.createStatement(); + + SQLException exception = new SQLException("xx", "xxx", 28); + mockConn.setError(exception); + + SQLException stmtErrror = null; + try { + stmt.setQueryTimeout(10); + } catch (SQLException ex) { + stmtErrror = ex; + } + Assert.assertNotNull(stmtErrror); + Assert.assertSame(exception, stmtErrror); + + SQLException commitError = null; + try { + conn.commit(); + } catch (SQLException ex) { + commitError = ex; + } + + Assert.assertNotNull(commitError); + Assert.assertSame(exception, commitError.getCause()); + + conn.close(); + } + +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_filters.java b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_filters.java new file mode 100644 index 0000000000..848d2a42a4 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_filters.java @@ -0,0 +1,33 @@ +package com.alibaba.druid.bvt.pool.property; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.util.JdbcUtils; + + +public class PropertyTest_filters extends TestCase { + private DruidDataSource dataSource; + + public void test_stat() { + System.setProperty("druid.filters", "stat"); + dataSource = new DruidDataSource(); + Assert.assertEquals(1, dataSource.getProxyFilters().size()); + Assert.assertEquals("com.alibaba.druid.filter.stat.StatFilter", dataSource.getFilterClassNames().get(0)); + } + + public void test_false() { + System.setProperty("druid.filters", ""); + dataSource = new DruidDataSource(); + Assert.assertEquals(0, dataSource.getProxyFilters().size()); + + Assert.assertNull(dataSource.getWallStatMap()); + } + + protected void tearDown() throws Exception { + System.clearProperty("druid.filters"); + JdbcUtils.close(dataSource); + } +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testOnBorrow.java b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testOnBorrow.java new file mode 100644 index 0000000000..444ab3ebc7 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testOnBorrow.java @@ -0,0 +1,32 @@ +package com.alibaba.druid.bvt.pool.property; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.util.JdbcUtils; + + +public class PropertyTest_testOnBorrow extends TestCase { + private DruidDataSource dataSource; + + public void test_true() { + System.setProperty("druid.testOnBorrow", "true"); + dataSource = new DruidDataSource(); + Assert.assertTrue(dataSource.isTestOnBorrow()); + } + + public void test_false() { + System.setProperty("druid.testOnBorrow", "false"); + dataSource = new DruidDataSource(); + Assert.assertFalse(dataSource.isTestOnBorrow()); + + Assert.assertNull(dataSource.getWallStatMap()); + } + + protected void tearDown() throws Exception { + System.clearProperty("druid.testOnBorrow"); + JdbcUtils.close(dataSource); + } +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testWhileIdle.java b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testWhileIdle.java new file mode 100644 index 0000000000..c169a92863 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_testWhileIdle.java @@ -0,0 +1,30 @@ +package com.alibaba.druid.bvt.pool.property; + +import org.junit.Assert; + +import junit.framework.TestCase; + +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.util.JdbcUtils; + + +public class PropertyTest_testWhileIdle extends TestCase { + private DruidDataSource dataSource; + + public void test_true() { + System.setProperty("druid.testWhileIdle", "true"); + dataSource = new DruidDataSource(); + Assert.assertTrue(dataSource.isTestWhileIdle()); + } + + public void test_false() { + System.setProperty("druid.testWhileIdle", "false"); + dataSource = new DruidDataSource(); + Assert.assertFalse(dataSource.isTestWhileIdle()); + } + + protected void tearDown() throws Exception { + System.clearProperty("druid.testWhileIdle"); + JdbcUtils.close(dataSource); + } +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_useGloalDataSourceStat.java b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_useGloalDataSourceStat.java new file mode 100644 index 0000000000..0972a1379d --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_useGloalDataSourceStat.java @@ -0,0 +1,30 @@ +package com.alibaba.druid.bvt.pool.property; + +import org.junit.Assert; + +import junit.framework.TestCase; + +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.util.JdbcUtils; + + +public class PropertyTest_useGloalDataSourceStat extends TestCase { + private DruidDataSource dataSource; + + public void test_true() { + System.setProperty("druid.useGloalDataSourceStat", "true"); + dataSource = new DruidDataSource(); + Assert.assertTrue(dataSource.isUseGloalDataSourceStat()); + } + + public void test_false() { + System.setProperty("druid.useGloalDataSourceStat", "false"); + dataSource = new DruidDataSource(); + Assert.assertFalse(dataSource.isUseGloalDataSourceStat()); + } + + protected void tearDown() throws Exception { + System.clearProperty("druid.useGloalDataSourceStat"); + JdbcUtils.close(dataSource); + } +} diff --git a/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_validationQuery.java b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_validationQuery.java new file mode 100644 index 0000000000..67cfabcc83 --- /dev/null +++ b/src/test/java/com/alibaba/druid/bvt/pool/property/PropertyTest_validationQuery.java @@ -0,0 +1,24 @@ +package com.alibaba.druid.bvt.pool.property; + +import junit.framework.TestCase; + +import org.junit.Assert; + +import com.alibaba.druid.pool.DruidDataSource; +import com.alibaba.druid.util.JdbcUtils; + + +public class PropertyTest_validationQuery extends TestCase { + private DruidDataSource dataSource; + + public void test_validationQuery() { + System.setProperty("druid.validationQuery", "select 1"); + dataSource = new DruidDataSource(); + Assert.assertEquals("select 1", dataSource.getValidationQuery()); + } + + protected void tearDown() throws Exception { + System.clearProperty("druid.validationQuery"); + JdbcUtils.close(dataSource); + } +}