[DBUTILS-139] Update Java requirement from version 6 to 7. Remove redundant specification of type arguments.
Project: http://git-wip-us.apache.org/repos/asf/commons-dbutils/repo Commit: http://git-wip-us.apache.org/repos/asf/commons-dbutils/commit/d484a72e Tree: http://git-wip-us.apache.org/repos/asf/commons-dbutils/tree/d484a72e Diff: http://git-wip-us.apache.org/repos/asf/commons-dbutils/diff/d484a72e Branch: refs/heads/master Commit: d484a72ebbb7153b8447fc0c1acc12ab537b1bc5 Parents: 1412385 Author: Gary Gregory <[email protected]> Authored: Fri May 4 14:26:30 2018 -0600 Committer: Gary Gregory <[email protected]> Committed: Fri May 4 14:26:30 2018 -0600 ---------------------------------------------------------------------- .../dbutils/BaseResultSetHandlerTest.java | 4 +- .../commons/dbutils/BeanProcessorTest.java | 2 +- .../commons/dbutils/OutParameterTest.java | 4 +- .../apache/commons/dbutils/QueryRunnerTest.java | 2072 +++++++++--------- .../dbutils/handlers/BeanHandlerTest.java | 4 +- .../dbutils/handlers/BeanListHandlerTest.java | 4 +- .../dbutils/handlers/BeanMapHandlerTest.java | 10 +- .../dbutils/handlers/ColumnListHandlerTest.java | 8 +- .../dbutils/handlers/KeyedHandlerTest.java | 8 +- .../dbutils/handlers/ScalarHandlerTest.java | 8 +- 10 files changed, 1062 insertions(+), 1062 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java b/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java index 569a591..e37422f 100644 --- a/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java +++ b/src/test/java/org/apache/commons/dbutils/BaseResultSetHandlerTest.java @@ -51,10 +51,10 @@ public final class BaseResultSetHandlerTest extends BaseTestCase { @Override protected Collection<Map<String, Object>> handle() throws SQLException { - Collection<Map<String, Object>> result = new LinkedList<Map<String, Object>>(); + Collection<Map<String, Object>> result = new LinkedList<>(); while (next()) { - Map<String, Object> current = new HashMap<String, Object>(); + Map<String, Object> current = new HashMap<>(); for (int i = 1; i <= getMetaData().getColumnCount(); i++) { current.put(getMetaData().getColumnName(i), getObject(i)); http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java b/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java index d73eca4..cb591a2 100644 --- a/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java +++ b/src/test/java/org/apache/commons/dbutils/BeanProcessorTest.java @@ -114,7 +114,7 @@ public class BeanProcessorTest extends BaseTestCase { } public void testMapColumnToPropertiesWithOverrides() throws Exception { - Map<String, String> columnToPropertyOverrides = new HashMap<String, String>(); + Map<String, String> columnToPropertyOverrides = new HashMap<>(); columnToPropertyOverrides.put("five", "four"); BeanProcessor beanProc = new BeanProcessor(columnToPropertyOverrides); String[] columnNames = { "test", "test", "three", "five" }; http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/OutParameterTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/OutParameterTest.java b/src/test/java/org/apache/commons/dbutils/OutParameterTest.java index 967c6e6..657a555 100644 --- a/src/test/java/org/apache/commons/dbutils/OutParameterTest.java +++ b/src/test/java/org/apache/commons/dbutils/OutParameterTest.java @@ -42,7 +42,7 @@ public class OutParameterTest { public void setUp() throws Exception { MockitoAnnotations.initMocks(this); // init the mocks - parameter = new OutParameter<Number>(Types.INTEGER, Number.class); + parameter = new OutParameter<>(Types.INTEGER, Number.class); } @Test @@ -68,7 +68,7 @@ public class OutParameterTest { @Test public void testRegisterAlternateConstructor() throws Exception { - parameter = new OutParameter<Number>(Types.INTEGER, Number.class, VALUE); + parameter = new OutParameter<>(Types.INTEGER, Number.class, VALUE); parameter.register(stmt, INDEX); verify(stmt, times(1)).registerOutParameter(INDEX, Types.INTEGER); verify(stmt, times(1)).setObject(INDEX, VALUE); http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java b/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java index 7d60b0f..ec8778c 100644 --- a/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java +++ b/src/test/java/org/apache/commons/dbutils/QueryRunnerTest.java @@ -1,1036 +1,1036 @@ -/* - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed with - * this work for additional information regarding copyright ownership. - * The ASF licenses this file to You 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 org.apache.commons.dbutils; - -import static org.junit.Assert.fail; -import static org.mockito.Matchers.any; -import static org.mockito.Matchers.eq; -import static org.mockito.Mockito.doThrow; -import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.never; -import static org.mockito.Mockito.times; -import static org.mockito.Mockito.verify; -import static org.mockito.Mockito.when; - -import java.sql.CallableStatement; -import java.sql.Connection; -import java.sql.ParameterMetaData; -import java.sql.PreparedStatement; -import java.sql.ResultSet; -import java.sql.ResultSetMetaData; -import java.sql.SQLException; -import java.sql.Statement; -import java.sql.Types; -import java.util.ArrayList; -import java.util.List; - -import javax.sql.DataSource; - -import org.apache.commons.dbutils.handlers.ArrayHandler; -import org.apache.commons.dbutils.handlers.ScalarHandler; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; -import org.mockito.Mock; -import org.mockito.MockitoAnnotations; -import org.mockito.invocation.InvocationOnMock; -import org.mockito.stubbing.Answer; - -@SuppressWarnings("boxing") // test code -public class QueryRunnerTest { - QueryRunner runner; - ArrayHandler handler; - - @Mock DataSource dataSource; - @Mock Connection conn; - @Mock PreparedStatement stmt; - @Mock CallableStatement call; - @Mock ParameterMetaData meta; - @Mock ResultSet results; - @Mock ResultSetMetaData resultsMeta; - - @Before - public void setUp() throws Exception { - MockitoAnnotations.initMocks(this); // init the mocks - - when(dataSource.getConnection()).thenReturn(conn); - when(conn.prepareStatement(any(String.class))).thenReturn(stmt); - when(stmt.getParameterMetaData()).thenReturn(meta); - when(stmt.getResultSet()).thenReturn(results); - when(stmt.executeQuery()).thenReturn(results); - when(conn.prepareCall(any(String.class))).thenReturn(call); - when(call.getParameterMetaData()).thenReturn(meta); - when(call.getResultSet()).thenReturn(results); - when(call.getMoreResults()).thenReturn(false); - when(results.next()).thenReturn(false); - - handler = new ArrayHandler(); - runner = new QueryRunner(dataSource); - } - - // - // Batch test cases - // - - private void callGoodBatch(Connection conn, Object[][] params) throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.batch(conn, "select * from blah where ? = ?", params); - - verify(stmt, times(2)).addBatch(); - verify(stmt, times(1)).executeBatch(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.batch(Connection, String, Object[][]) does not close connections - } - - private void callGoodBatch(Object[][] params) throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.batch("select * from blah where ? = ?", params); - - verify(stmt, times(2)).addBatch(); - verify(stmt, times(1)).executeBatch(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - } - - @Test - public void testGoodBatch() throws Exception { - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - callGoodBatch(params); - } - - @Test - public void testGoodBatchPmdTrue() throws Exception { - runner = new QueryRunner(dataSource, true); - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - callGoodBatch(params); - } - - @Test - public void testGoodBatchDefaultConstructor() throws Exception { - runner = new QueryRunner(); - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - callGoodBatch(conn, params); - } - - @Test - public void testNullParamsBatch() throws Exception { - String[][] params = new String[][] { { null, "unit" }, { "test", null } }; - - callGoodBatch(params); - } - - - - // helper method for calling batch when an exception is expected - private void callBatchWithException(String sql, Object[][] params) throws Exception { - boolean caught = false; - - try { - runner.batch(sql, params); - - verify(stmt, times(2)).addBatch(); - verify(stmt, times(1)).executeBatch(); - verify(stmt, times(1)).close(); // make sure the statement is closed - verify(conn, times(1)).close(); // make sure the connection is closed - } catch(SQLException e) { - caught = true; - } - - if(!caught) { - fail("Exception never thrown, but expected"); - } - } - - @Test - public void testTooFewParamsBatch() throws Exception { - String[][] params = new String[][] { { "unit" }, { "test" } }; - - callBatchWithException("select * from blah where ? = ?", params); - } - - @Test - public void testTooManyParamsBatch() throws Exception { - String[][] params = new String[][] { { "unit", "unit", "unit" }, { "test", "test", "test" } }; - - callBatchWithException("select * from blah where ? = ?", params); - } - - @Test(expected=SQLException.class) - public void testNullConnectionBatch() throws Exception { - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - when(meta.getParameterCount()).thenReturn(2); - when(dataSource.getConnection()).thenReturn(null); - - runner.batch("select * from blah where ? = ?", params); - } - - @Test(expected=SQLException.class) - public void testNullSqlBatch() throws Exception { - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - when(meta.getParameterCount()).thenReturn(2); - - runner.batch(null, params); - } - - @Test(expected=SQLException.class) - public void testNullParamsArgBatch() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.batch("select * from blah where ? = ?", null); - } - - @Test - public void testAddBatchException() throws Exception { - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - doThrow(new SQLException()).when(stmt).addBatch(); - - callBatchWithException("select * from blah where ? = ?", params); - } - - @Test - public void testExecuteBatchException() throws Exception { - String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; - - doThrow(new SQLException()).when(stmt).executeBatch(); - - callBatchWithException("select * from blah where ? = ?", params); - } - - - // - // Query test cases - // - private void callGoodQuery(Connection conn) throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.query(conn, "select * from blah where ? = ?", handler, "unit", "test"); - - verify(stmt, times(1)).executeQuery(); - verify(results, times(1)).close(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.query(Connection, String, ResultSetHandler<T>, Object...) does not close connections - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - runner.query(conn, "select * from blah", handler); - - verify(stmt, times(2)).executeQuery(); - verify(results, times(2)).close(); - verify(stmt, times(2)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, see above - } - - private void callGoodQuery() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.query("select * from blah where ? = ?", handler, "unit", "test"); - - verify(stmt, times(1)).executeQuery(); - verify(results, times(1)).close(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - runner.query("select * from blah", handler); - - verify(stmt, times(2)).executeQuery(); - verify(results, times(2)).close(); - verify(stmt, times(2)).close(); // make sure we closed the statement - verify(conn, times(2)).close(); // make sure we closed the connection - } - - @Test - public void testGoodQuery() throws Exception { - callGoodQuery(); - } - - @Test - public void testGoodQueryPmdTrue() throws Exception { - runner = new QueryRunner(true); - callGoodQuery(conn); - } - - @Test - public void testGoodQueryDefaultConstructor() throws Exception { - runner = new QueryRunner(); - callGoodQuery(conn); - } - - - // helper method for calling batch when an exception is expected - private void callQueryWithException(Object... params) throws Exception { - boolean caught = false; - - try { - when(meta.getParameterCount()).thenReturn(2); - runner.query("select * from blah where ? = ?", handler, params); - - verify(stmt, never()).close(); // make sure the statement is still open - verify(stmt, times(1)).executeQuery(); - verify(results, times(1)).close(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - } catch(SQLException e) { - caught = true; - } - - if(!caught) { - fail("Exception never thrown, but expected"); - } - } - - @Test - public void testNoParamsQuery() throws Exception { - callQueryWithException(); - } - - @Test - public void testTooFewParamsQuery() throws Exception { - callQueryWithException("unit"); - } - - @Test - public void testTooManyParamsQuery() throws Exception { - callQueryWithException("unit", "test", "fail"); - } - - @Test(expected=SQLException.class) - public void testNullConnectionQuery() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - when(dataSource.getConnection()).thenReturn(null); - - runner.query("select * from blah where ? = ?", handler, "unit", "test"); - } - - @Test(expected=SQLException.class) - public void testNullSqlQuery() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.query(null, handler); - } - - @Test(expected=SQLException.class) - public void testNullHandlerQuery() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.query("select * from blah where ? = ?", null); - } - - @Test - public void testExecuteQueryException() throws Exception { - doThrow(new SQLException()).when(stmt).executeQuery(); - - callQueryWithException(handler, "unit", "test"); - } - - - // - // Update test cases - // - private void callGoodUpdate(Connection conn) throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.update(conn, "update blah set ? = ?", "unit", "test"); - - verify(stmt, times(1)).executeUpdate(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.update(Connection, String, Object...) does not close connections - - // call the other variation - when(meta.getParameterCount()).thenReturn(0); - runner.update(conn, "update blah set unit = test"); - - verify(stmt, times(2)).executeUpdate(); - verify(stmt, times(2)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, see above - - // call the other variation - when(meta.getParameterCount()).thenReturn(1); - runner.update(conn, "update blah set unit = ?", "test"); - - verify(stmt, times(3)).executeUpdate(); - verify(stmt, times(3)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection, see above - } - - private void callGoodUpdate() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - runner.update("update blah set ? = ?", "unit", "test"); - - verify(stmt, times(1)).executeUpdate(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - - // call the other variation - when(meta.getParameterCount()).thenReturn(0); - runner.update("update blah set unit = test"); - - verify(stmt, times(2)).executeUpdate(); - verify(stmt, times(2)).close(); // make sure we closed the statement - verify(conn, times(2)).close(); // make sure we closed the connection - - // call the other variation - when(meta.getParameterCount()).thenReturn(1); - runner.update("update blah set unit = ?", "test"); - - verify(stmt, times(3)).executeUpdate(); - verify(stmt, times(3)).close(); // make sure we closed the statement - verify(conn, times(3)).close(); // make sure we closed the connection - } - - @Test - public void testGoodUpdate() throws Exception { - callGoodUpdate(); - } - - @Test - public void testGoodUpdatePmdTrue() throws Exception { - runner = new QueryRunner(true); - callGoodUpdate(conn); - } - - @Test - public void testGoodUpdateDefaultConstructor() throws Exception { - runner = new QueryRunner(); - callGoodUpdate(conn); - } - - @Test - public void testGoodInsert() throws Exception { - results = mock(ResultSet.class); - - when(meta.getParameterCount()).thenReturn(2); - when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt); - when(stmt.getGeneratedKeys()).thenReturn(results); - when(results.next()).thenReturn(true).thenReturn(false); - when(results.getObject(1)).thenReturn(1L); - - Long generatedKey = runner.insert("INSERT INTO blah(col1, col2) VALUES(?,?)", new ScalarHandler<Long>(), "unit", "test"); - - verify(stmt, times(1)).executeUpdate(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - - Assert.assertEquals(1L, generatedKey.longValue()); - } - - @Test - public void testGoodBatchInsert() throws Exception { - results = mock(ResultSet.class); - resultsMeta = mock(ResultSetMetaData.class); - - when(meta.getParameterCount()).thenReturn(2); - when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt); - when(stmt.getGeneratedKeys()).thenReturn(results); - when(results.next()).thenReturn(true).thenReturn(true).thenReturn(false); - when(results.getMetaData()).thenReturn(resultsMeta); - when(resultsMeta.getColumnCount()).thenReturn(1); - - ResultSetHandler<List<Object>> handler = new ResultSetHandler<List<Object>>() - { - @Override - public List<Object> handle(ResultSet rs) throws SQLException - { - List<Object> objects = new ArrayList<Object>(); - while (rs.next()) - { - objects.add(new Object()); - } - return objects; - } - }; - - Object[][] params = new Object[2][2]; - params[0][0] = "Test"; - params[0][1] = "Blah"; - params[1][0] = "Test2"; - params[1][1] = "Blah2"; - - List<Object> generatedKeys = runner.insertBatch("INSERT INTO blah(col1, col2) VALUES(?,?)", handler, params); - - verify(stmt, times(2)).addBatch(); - verify(stmt, times(1)).executeBatch(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - - Assert.assertEquals(2, generatedKeys.size()); - } - - // helper method for calling batch when an exception is expected - private void callUpdateWithException(Object... params) throws Exception { - boolean caught = false; - - try { - when(meta.getParameterCount()).thenReturn(2); - runner.update("select * from blah where ? = ?", params); - - verify(stmt, times(1)).executeUpdate(); - verify(stmt, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we closed the connection - } catch(SQLException e) { - caught = true; - } - - if(!caught) { - fail("Exception never thrown, but expected"); - } - } - - @Test - public void testNoParamsUpdate() throws Exception { - callUpdateWithException(); - } - - @Test - public void testTooFewParamsUpdate() throws Exception { - callUpdateWithException("unit"); - } - - @Test - public void testTooManyParamsUpdate() throws Exception { - callUpdateWithException("unit", "test", "fail"); - } - - @Test(expected=SQLException.class) - public void testNullConnectionUpdate() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - when(dataSource.getConnection()).thenReturn(null); - - runner.update("select * from blah where ? = ?", "unit", "test"); - } - - @Test(expected=SQLException.class) - public void testNullSqlUpdate() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.update(null); - } - - @Test - public void testExecuteUpdateException() throws Exception { - doThrow(new SQLException()).when(stmt).executeUpdate(); - - callUpdateWithException("unit", "test"); - } - - @Test - public void testStatementConfiguration() throws Exception { - StatementConfiguration stmtConfig = new StatementConfiguration(1, 2, 3, 4, 5); - QueryRunner queryRunner = new QueryRunner(stmtConfig); - queryRunner.prepareStatement(conn, "select 1"); - - verify(stmt).setFetchDirection(eq(1)); - verify(stmt).setFetchSize(eq(2)); - verify(stmt).setMaxFieldSize(eq(3)); - verify(stmt).setMaxRows(eq(4)); - verify(stmt).setQueryTimeout(eq(5)); - } - - // - // Execute tests - // - private void callGoodExecute(Connection conn) throws Exception { - when(call.execute()).thenReturn(false); - when(call.getUpdateCount()).thenReturn(3); - - when(meta.getParameterCount()).thenReturn(2); - int result = runner.execute(conn, "{call my_proc(?, ?)}", "unit", "test"); - - Assert.assertEquals(3, result); - - verify(call, times(1)).execute(); - verify(call, times(1)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - result = runner.execute(conn, "{call my_proc()}"); - - Assert.assertEquals(3, result); - - verify(call, times(2)).execute(); - verify(call, times(2)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test single OUT parameter - when(meta.getParameterCount()).thenReturn(1); - when(call.getObject(1)).thenReturn(42); - OutParameter<Integer> intParam = - new OutParameter<Integer>(Types.INTEGER, Integer.class); - result = runner.execute(conn, "{?= call my_proc()}", intParam); - - Assert.assertEquals(42, intParam.getValue().intValue()); - Assert.assertEquals(3, result); - - verify(call, times(3)).execute(); - verify(call, times(3)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test OUT parameters with IN parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(4242); - intParam.setValue(null); - result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "unit", "test"); - - Assert.assertEquals(4242, intParam.getValue().intValue()); - Assert.assertEquals(3, result); - - verify(call, times(4)).execute(); - verify(call, times(4)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test INOUT parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(24); - when(call.getObject(3)).thenReturn("out"); - intParam.setValue(null); - OutParameter<String> stringParam = - new OutParameter<String>(Types.VARCHAR, String.class, "in"); - result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "test", stringParam); - - Assert.assertEquals(24, intParam.getValue().intValue()); - Assert.assertEquals("out", stringParam.getValue()); - Assert.assertEquals(3, result); - - verify(call, times(5)).execute(); - verify(call, times(5)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - } - - private void callGoodExecute() throws Exception { - when(call.execute()).thenReturn(false); - when(call.getUpdateCount()).thenReturn(3); - - when(meta.getParameterCount()).thenReturn(2); - int result = runner.execute("{call my_proc(?, ?)}", "unit", "test"); - - Assert.assertEquals(3, result); - - verify(call, times(1)).execute(); - verify(call, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we do not close the connection - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - result = runner.execute("{call my_proc()}"); - - Assert.assertEquals(3, result); - - verify(call, times(2)).execute(); - verify(call, times(2)).close(); // make sure we closed the statement - verify(conn, times(2)).close(); // make sure we do not close the connection - - // Test single OUT parameter - when(meta.getParameterCount()).thenReturn(1); - when(call.getObject(1)).thenReturn(42); - OutParameter<Integer> intParam = - new OutParameter<Integer>(Types.INTEGER, Integer.class); - result = runner.execute("{?= call my_proc()}", intParam); - - Assert.assertEquals(42, intParam.getValue().intValue()); - Assert.assertEquals(3, result); - - verify(call, times(3)).execute(); - verify(call, times(3)).close(); // make sure we closed the statement - verify(conn, times(3)).close(); // make sure we do not close the connection - - // Test OUT parameters with IN parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(4242); - intParam.setValue(null); - result = runner.execute("{?= call my_proc(?, ?)}", intParam, "unit", "test"); - - Assert.assertEquals(4242, intParam.getValue().intValue()); - Assert.assertEquals(3, result); - - verify(call, times(4)).execute(); - verify(call, times(4)).close(); // make sure we closed the statement - verify(conn, times(4)).close(); // make sure we do not close the connection - - // Test INOUT parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(24); - when(call.getObject(3)).thenReturn("out"); - intParam.setValue(null); - OutParameter<String> stringParam = - new OutParameter<String>(Types.VARCHAR, String.class, "in"); - result = runner.execute("{?= call my_proc(?, ?)}", intParam, "test", stringParam); - - Assert.assertEquals(24, intParam.getValue().intValue()); - Assert.assertEquals("out", stringParam.getValue()); - Assert.assertEquals(3, result); - - verify(call, times(5)).execute(); - verify(call, times(5)).close(); // make sure we closed the statement - verify(conn, times(5)).close(); // make sure we do not close the connection - } - - @Test - public void testGoodExecute() throws Exception { - callGoodExecute(); - } - - @Test - public void testGoodExecutePmdTrue() throws Exception { - runner = new QueryRunner(true); - callGoodExecute(conn); - } - - @Test - public void testGoodExecuteDefaultConstructor() throws Exception { - runner = new QueryRunner(); - callGoodExecute(conn); - } - - // helper method for calling execute when an exception is expected - private void callExecuteWithException(Object... params) throws Exception { - boolean caught = false; - - try { - when(call.execute()).thenReturn(false); - when(meta.getParameterCount()).thenReturn(2); - runner.query("{call my_proc(?, ?)}", handler, params); - - } catch(SQLException e) { - caught = true; - } - - if(!caught) { - fail("Exception never thrown, but expected"); - } - } - - @Test - public void testNoParamsExecute() throws Exception { - callExecuteWithException(); - } - - @Test - public void testTooFewParamsExecute() throws Exception { - callExecuteWithException("unit"); - } - - @Test - public void testTooManyParamsExecute() throws Exception { - callExecuteWithException("unit", "test", "fail"); - } - - @Test(expected=SQLException.class) - public void testNullConnectionExecute() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - when(dataSource.getConnection()).thenReturn(null); - - runner.execute("{call my_proc(?, ?)}", "unit", "test"); - } - - @Test(expected=SQLException.class) - public void testNullSqlExecute() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.execute(null); - } - - @Test(expected=SQLException.class) - public void testNullHandlerExecute() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.execute("{call my_proc(?, ?)}"); - } - - @Test - public void testExecuteException() throws Exception { - doThrow(new SQLException()).when(stmt).execute(); - - callExecuteWithException(handler, "unit", "test"); - } - - // - // Execute with ResultSetHandler - // - - @Test - public void testExecuteWithMultipleResultSets() throws Exception { - when(call.execute()).thenReturn(true); - when(call.getMoreResults()).thenAnswer(new Answer<Boolean>() - { - int count = 1; - @Override - public Boolean answer(InvocationOnMock invocation) - { - return ++count <= 3; - } - }); - when(meta.getParameterCount()).thenReturn(0); - List<Object[]> objects = runner.execute("{call my_proc()}", handler); - - Assert.assertEquals(3, objects.size()); - verify(call, times(1)).execute(); - verify(results, times(3)).close(); - verify(call, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we close the connection - - } - - private void callGoodExecuteWithResultSet(Connection conn) throws Exception { - when(call.execute()).thenReturn(true); - - when(meta.getParameterCount()).thenReturn(2); - runner.execute(conn, "{call my_proc(?, ?)}", handler, "unit", "test"); - - verify(call, times(1)).execute(); - verify(results, times(1)).close(); - verify(call, times(1)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - runner.execute(conn, "{call my_proc()}", handler); - - verify(call, times(2)).execute(); - verify(results, times(2)).close(); - verify(call, times(2)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test single OUT parameter - when(meta.getParameterCount()).thenReturn(1); - when(call.getObject(1)).thenReturn(42); - OutParameter<Integer> intParam = - new OutParameter<Integer>(Types.INTEGER, Integer.class); - runner.execute(conn, "{?= call my_proc()}", handler, intParam); - - Assert.assertEquals(42, intParam.getValue().intValue()); - - verify(call, times(3)).execute(); - verify(results, times(3)).close(); - verify(call, times(3)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test OUT parameters with IN parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(4242); - intParam.setValue(null); - runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "unit", "test"); - - Assert.assertEquals(4242, intParam.getValue().intValue()); - - verify(call, times(4)).execute(); - verify(results, times(4)).close(); - verify(call, times(4)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - - // Test INOUT parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(24); - when(call.getObject(3)).thenReturn("out"); - intParam.setValue(null); - OutParameter<String> stringParam = - new OutParameter<String>(Types.VARCHAR, String.class, "in"); - runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam); - - Assert.assertEquals(24, intParam.getValue().intValue()); - Assert.assertEquals("out", stringParam.getValue()); - - verify(call, times(5)).execute(); - verify(results, times(5)).close(); - verify(call, times(5)).close(); // make sure we closed the statement - verify(conn, times(0)).close(); // make sure we do not close the connection - } - - private void callGoodExecuteWithResultSet() throws Exception { - when(call.execute()).thenReturn(true); - - when(meta.getParameterCount()).thenReturn(2); - runner.execute("{call my_proc(?, ?)}", handler, "unit", "test"); - - verify(call, times(1)).execute(); - verify(results, times(1)).close(); - verify(call, times(1)).close(); // make sure we closed the statement - verify(conn, times(1)).close(); // make sure we do not close the connection - - // call the other variation of query - when(meta.getParameterCount()).thenReturn(0); - runner.execute("{call my_proc()}", handler); - - verify(call, times(2)).execute(); - verify(results, times(2)).close(); - verify(call, times(2)).close(); // make sure we closed the statement - verify(conn, times(2)).close(); // make sure we do not close the connection - - // Test single OUT parameter - when(meta.getParameterCount()).thenReturn(1); - when(call.getObject(1)).thenReturn(42); - OutParameter<Integer> intParam = - new OutParameter<Integer>(Types.INTEGER, Integer.class); - runner.execute("{?= call my_proc()}", handler, intParam); - - Assert.assertEquals(42, intParam.getValue().intValue()); - - verify(call, times(3)).execute(); - verify(results, times(3)).close(); - verify(call, times(3)).close(); // make sure we closed the statement - verify(conn, times(3)).close(); // make sure we do not close the connection - - // Test OUT parameters with IN parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(4242); - intParam.setValue(null); - runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "unit", "test"); - - Assert.assertEquals(4242, intParam.getValue().intValue()); - - verify(call, times(4)).execute(); - verify(results, times(4)).close(); - verify(call, times(4)).close(); // make sure we closed the statement - verify(conn, times(4)).close(); // make sure we do not close the connection - - // Test INOUT parameters - when(meta.getParameterCount()).thenReturn(3); - when(call.getObject(1)).thenReturn(24); - when(call.getObject(3)).thenReturn("out"); - intParam.setValue(null); - OutParameter<String> stringParam = - new OutParameter<String>(Types.VARCHAR, String.class, "in"); - runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam); - - Assert.assertEquals(24, intParam.getValue().intValue()); - Assert.assertEquals("out", stringParam.getValue()); - - verify(call, times(5)).execute(); - verify(results, times(5)).close(); - verify(call, times(5)).close(); // make sure we closed the statement - verify(conn, times(5)).close(); // make sure we do not close the connection - } - - @Test - public void testGoodExecuteWithResultSet() throws Exception { - callGoodExecuteWithResultSet(); - } - - @Test - public void testGoodExecuteWithResultSetPmdTrue() throws Exception { - runner = new QueryRunner(true); - callGoodExecuteWithResultSet(conn); - } - - @Test - public void testGoodExecuteWithResultSetDefaultConstructor() throws Exception { - runner = new QueryRunner(); - callGoodExecuteWithResultSet(conn); - } - - // helper method for calling execute when an exception is expected - private void callExecuteWithResultSetWithException(Object... params) throws Exception { - boolean caught = false; - - try { - when(call.execute()).thenReturn(true); - when(meta.getParameterCount()).thenReturn(2); - runner.query("{call my_proc(?, ?)}", handler, params); - - } catch(SQLException e) { - caught = true; - } - - if(!caught) { - fail("Exception never thrown, but expected"); - } - } - - @Test - public void testNoParamsExecuteWithResultSet() throws Exception { - callExecuteWithResultSetWithException(); - } - - @Test - public void testTooFewParamsExecuteWithResultSet() throws Exception { - callExecuteWithResultSetWithException("unit"); - } - - @Test - public void testTooManyParamsExecuteWithResultSet() throws Exception { - callExecuteWithResultSetWithException("unit", "test", "fail"); - } - - @Test(expected=SQLException.class) - public void testNullConnectionExecuteWithResultSet() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - when(dataSource.getConnection()).thenReturn(null); - - runner.execute("{call my_proc(?, ?)}", handler, "unit", "test"); - } - - @Test(expected=SQLException.class) - public void testNullSqlExecuteWithResultSet() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.execute(null, handler); - } - - @Test(expected=SQLException.class) - public void testNullHandlerExecuteWithResultSet() throws Exception { - when(meta.getParameterCount()).thenReturn(2); - - runner.execute("{call my_proc(?, ?)}", (ResultSetHandler)null); - } - - @Test - public void testExecuteWithResultSetException() throws Exception { - doThrow(new SQLException()).when(stmt).execute(); - - callExecuteWithResultSetWithException(handler, "unit", "test"); - } - - // - // Random tests - // - class MyBean { - private int a; - private double b; - private String c; - - public int getA() { return a; } - public void setA(int a) { this.a = a; } - public double getB() { return b; } - public void setB(double b) { this.b = b; } - public String getC() { return c; } - public void setC(String c) { this.c = c; } - } - - @Test - public void testFillStatementWithBean() throws Exception { - MyBean bean = new MyBean(); - when(meta.getParameterCount()).thenReturn(3); - runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", "c" }); - } - - @Test(expected=NullPointerException.class) - public void testFillStatementWithBeanNullNames() throws Exception { - MyBean bean = new MyBean(); - when(meta.getParameterCount()).thenReturn(3); - runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", null }); - } - - @Test(expected=SQLException.class) - public void testBadPrepareConnection() throws Exception { - runner = new QueryRunner(); - runner.update("update blah set unit = test"); - } -} +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You 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 org.apache.commons.dbutils; + +import static org.junit.Assert.fail; +import static org.mockito.Matchers.any; +import static org.mockito.Matchers.eq; +import static org.mockito.Mockito.doThrow; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import java.sql.CallableStatement; +import java.sql.Connection; +import java.sql.ParameterMetaData; +import java.sql.PreparedStatement; +import java.sql.ResultSet; +import java.sql.ResultSetMetaData; +import java.sql.SQLException; +import java.sql.Statement; +import java.sql.Types; +import java.util.ArrayList; +import java.util.List; + +import javax.sql.DataSource; + +import org.apache.commons.dbutils.handlers.ArrayHandler; +import org.apache.commons.dbutils.handlers.ScalarHandler; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; + +@SuppressWarnings("boxing") // test code +public class QueryRunnerTest { + QueryRunner runner; + ArrayHandler handler; + + @Mock DataSource dataSource; + @Mock Connection conn; + @Mock PreparedStatement stmt; + @Mock CallableStatement call; + @Mock ParameterMetaData meta; + @Mock ResultSet results; + @Mock ResultSetMetaData resultsMeta; + + @Before + public void setUp() throws Exception { + MockitoAnnotations.initMocks(this); // init the mocks + + when(dataSource.getConnection()).thenReturn(conn); + when(conn.prepareStatement(any(String.class))).thenReturn(stmt); + when(stmt.getParameterMetaData()).thenReturn(meta); + when(stmt.getResultSet()).thenReturn(results); + when(stmt.executeQuery()).thenReturn(results); + when(conn.prepareCall(any(String.class))).thenReturn(call); + when(call.getParameterMetaData()).thenReturn(meta); + when(call.getResultSet()).thenReturn(results); + when(call.getMoreResults()).thenReturn(false); + when(results.next()).thenReturn(false); + + handler = new ArrayHandler(); + runner = new QueryRunner(dataSource); + } + + // + // Batch test cases + // + + private void callGoodBatch(Connection conn, Object[][] params) throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.batch(conn, "select * from blah where ? = ?", params); + + verify(stmt, times(2)).addBatch(); + verify(stmt, times(1)).executeBatch(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.batch(Connection, String, Object[][]) does not close connections + } + + private void callGoodBatch(Object[][] params) throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.batch("select * from blah where ? = ?", params); + + verify(stmt, times(2)).addBatch(); + verify(stmt, times(1)).executeBatch(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + } + + @Test + public void testGoodBatch() throws Exception { + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + callGoodBatch(params); + } + + @Test + public void testGoodBatchPmdTrue() throws Exception { + runner = new QueryRunner(dataSource, true); + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + callGoodBatch(params); + } + + @Test + public void testGoodBatchDefaultConstructor() throws Exception { + runner = new QueryRunner(); + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + callGoodBatch(conn, params); + } + + @Test + public void testNullParamsBatch() throws Exception { + String[][] params = new String[][] { { null, "unit" }, { "test", null } }; + + callGoodBatch(params); + } + + + + // helper method for calling batch when an exception is expected + private void callBatchWithException(String sql, Object[][] params) throws Exception { + boolean caught = false; + + try { + runner.batch(sql, params); + + verify(stmt, times(2)).addBatch(); + verify(stmt, times(1)).executeBatch(); + verify(stmt, times(1)).close(); // make sure the statement is closed + verify(conn, times(1)).close(); // make sure the connection is closed + } catch(SQLException e) { + caught = true; + } + + if(!caught) { + fail("Exception never thrown, but expected"); + } + } + + @Test + public void testTooFewParamsBatch() throws Exception { + String[][] params = new String[][] { { "unit" }, { "test" } }; + + callBatchWithException("select * from blah where ? = ?", params); + } + + @Test + public void testTooManyParamsBatch() throws Exception { + String[][] params = new String[][] { { "unit", "unit", "unit" }, { "test", "test", "test" } }; + + callBatchWithException("select * from blah where ? = ?", params); + } + + @Test(expected=SQLException.class) + public void testNullConnectionBatch() throws Exception { + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + when(meta.getParameterCount()).thenReturn(2); + when(dataSource.getConnection()).thenReturn(null); + + runner.batch("select * from blah where ? = ?", params); + } + + @Test(expected=SQLException.class) + public void testNullSqlBatch() throws Exception { + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + when(meta.getParameterCount()).thenReturn(2); + + runner.batch(null, params); + } + + @Test(expected=SQLException.class) + public void testNullParamsArgBatch() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.batch("select * from blah where ? = ?", null); + } + + @Test + public void testAddBatchException() throws Exception { + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + doThrow(new SQLException()).when(stmt).addBatch(); + + callBatchWithException("select * from blah where ? = ?", params); + } + + @Test + public void testExecuteBatchException() throws Exception { + String[][] params = new String[][] { { "unit", "unit" }, { "test", "test" } }; + + doThrow(new SQLException()).when(stmt).executeBatch(); + + callBatchWithException("select * from blah where ? = ?", params); + } + + + // + // Query test cases + // + private void callGoodQuery(Connection conn) throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.query(conn, "select * from blah where ? = ?", handler, "unit", "test"); + + verify(stmt, times(1)).executeQuery(); + verify(results, times(1)).close(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.query(Connection, String, ResultSetHandler<T>, Object...) does not close connections + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + runner.query(conn, "select * from blah", handler); + + verify(stmt, times(2)).executeQuery(); + verify(results, times(2)).close(); + verify(stmt, times(2)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, see above + } + + private void callGoodQuery() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.query("select * from blah where ? = ?", handler, "unit", "test"); + + verify(stmt, times(1)).executeQuery(); + verify(results, times(1)).close(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + runner.query("select * from blah", handler); + + verify(stmt, times(2)).executeQuery(); + verify(results, times(2)).close(); + verify(stmt, times(2)).close(); // make sure we closed the statement + verify(conn, times(2)).close(); // make sure we closed the connection + } + + @Test + public void testGoodQuery() throws Exception { + callGoodQuery(); + } + + @Test + public void testGoodQueryPmdTrue() throws Exception { + runner = new QueryRunner(true); + callGoodQuery(conn); + } + + @Test + public void testGoodQueryDefaultConstructor() throws Exception { + runner = new QueryRunner(); + callGoodQuery(conn); + } + + + // helper method for calling batch when an exception is expected + private void callQueryWithException(Object... params) throws Exception { + boolean caught = false; + + try { + when(meta.getParameterCount()).thenReturn(2); + runner.query("select * from blah where ? = ?", handler, params); + + verify(stmt, never()).close(); // make sure the statement is still open + verify(stmt, times(1)).executeQuery(); + verify(results, times(1)).close(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + } catch(SQLException e) { + caught = true; + } + + if(!caught) { + fail("Exception never thrown, but expected"); + } + } + + @Test + public void testNoParamsQuery() throws Exception { + callQueryWithException(); + } + + @Test + public void testTooFewParamsQuery() throws Exception { + callQueryWithException("unit"); + } + + @Test + public void testTooManyParamsQuery() throws Exception { + callQueryWithException("unit", "test", "fail"); + } + + @Test(expected=SQLException.class) + public void testNullConnectionQuery() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + when(dataSource.getConnection()).thenReturn(null); + + runner.query("select * from blah where ? = ?", handler, "unit", "test"); + } + + @Test(expected=SQLException.class) + public void testNullSqlQuery() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.query(null, handler); + } + + @Test(expected=SQLException.class) + public void testNullHandlerQuery() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.query("select * from blah where ? = ?", null); + } + + @Test + public void testExecuteQueryException() throws Exception { + doThrow(new SQLException()).when(stmt).executeQuery(); + + callQueryWithException(handler, "unit", "test"); + } + + + // + // Update test cases + // + private void callGoodUpdate(Connection conn) throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.update(conn, "update blah set ? = ?", "unit", "test"); + + verify(stmt, times(1)).executeUpdate(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, since QueryRunner.update(Connection, String, Object...) does not close connections + + // call the other variation + when(meta.getParameterCount()).thenReturn(0); + runner.update(conn, "update blah set unit = test"); + + verify(stmt, times(2)).executeUpdate(); + verify(stmt, times(2)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, see above + + // call the other variation + when(meta.getParameterCount()).thenReturn(1); + runner.update(conn, "update blah set unit = ?", "test"); + + verify(stmt, times(3)).executeUpdate(); + verify(stmt, times(3)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection, see above + } + + private void callGoodUpdate() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + runner.update("update blah set ? = ?", "unit", "test"); + + verify(stmt, times(1)).executeUpdate(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + + // call the other variation + when(meta.getParameterCount()).thenReturn(0); + runner.update("update blah set unit = test"); + + verify(stmt, times(2)).executeUpdate(); + verify(stmt, times(2)).close(); // make sure we closed the statement + verify(conn, times(2)).close(); // make sure we closed the connection + + // call the other variation + when(meta.getParameterCount()).thenReturn(1); + runner.update("update blah set unit = ?", "test"); + + verify(stmt, times(3)).executeUpdate(); + verify(stmt, times(3)).close(); // make sure we closed the statement + verify(conn, times(3)).close(); // make sure we closed the connection + } + + @Test + public void testGoodUpdate() throws Exception { + callGoodUpdate(); + } + + @Test + public void testGoodUpdatePmdTrue() throws Exception { + runner = new QueryRunner(true); + callGoodUpdate(conn); + } + + @Test + public void testGoodUpdateDefaultConstructor() throws Exception { + runner = new QueryRunner(); + callGoodUpdate(conn); + } + + @Test + public void testGoodInsert() throws Exception { + results = mock(ResultSet.class); + + when(meta.getParameterCount()).thenReturn(2); + when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt); + when(stmt.getGeneratedKeys()).thenReturn(results); + when(results.next()).thenReturn(true).thenReturn(false); + when(results.getObject(1)).thenReturn(1L); + + Long generatedKey = runner.insert("INSERT INTO blah(col1, col2) VALUES(?,?)", new ScalarHandler<Long>(), "unit", "test"); + + verify(stmt, times(1)).executeUpdate(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + + Assert.assertEquals(1L, generatedKey.longValue()); + } + + @Test + public void testGoodBatchInsert() throws Exception { + results = mock(ResultSet.class); + resultsMeta = mock(ResultSetMetaData.class); + + when(meta.getParameterCount()).thenReturn(2); + when(conn.prepareStatement(any(String.class), eq(Statement.RETURN_GENERATED_KEYS))).thenReturn(stmt); + when(stmt.getGeneratedKeys()).thenReturn(results); + when(results.next()).thenReturn(true).thenReturn(true).thenReturn(false); + when(results.getMetaData()).thenReturn(resultsMeta); + when(resultsMeta.getColumnCount()).thenReturn(1); + + ResultSetHandler<List<Object>> handler = new ResultSetHandler<List<Object>>() + { + @Override + public List<Object> handle(ResultSet rs) throws SQLException + { + List<Object> objects = new ArrayList<>(); + while (rs.next()) + { + objects.add(new Object()); + } + return objects; + } + }; + + Object[][] params = new Object[2][2]; + params[0][0] = "Test"; + params[0][1] = "Blah"; + params[1][0] = "Test2"; + params[1][1] = "Blah2"; + + List<Object> generatedKeys = runner.insertBatch("INSERT INTO blah(col1, col2) VALUES(?,?)", handler, params); + + verify(stmt, times(2)).addBatch(); + verify(stmt, times(1)).executeBatch(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + + Assert.assertEquals(2, generatedKeys.size()); + } + + // helper method for calling batch when an exception is expected + private void callUpdateWithException(Object... params) throws Exception { + boolean caught = false; + + try { + when(meta.getParameterCount()).thenReturn(2); + runner.update("select * from blah where ? = ?", params); + + verify(stmt, times(1)).executeUpdate(); + verify(stmt, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we closed the connection + } catch(SQLException e) { + caught = true; + } + + if(!caught) { + fail("Exception never thrown, but expected"); + } + } + + @Test + public void testNoParamsUpdate() throws Exception { + callUpdateWithException(); + } + + @Test + public void testTooFewParamsUpdate() throws Exception { + callUpdateWithException("unit"); + } + + @Test + public void testTooManyParamsUpdate() throws Exception { + callUpdateWithException("unit", "test", "fail"); + } + + @Test(expected=SQLException.class) + public void testNullConnectionUpdate() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + when(dataSource.getConnection()).thenReturn(null); + + runner.update("select * from blah where ? = ?", "unit", "test"); + } + + @Test(expected=SQLException.class) + public void testNullSqlUpdate() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.update(null); + } + + @Test + public void testExecuteUpdateException() throws Exception { + doThrow(new SQLException()).when(stmt).executeUpdate(); + + callUpdateWithException("unit", "test"); + } + + @Test + public void testStatementConfiguration() throws Exception { + StatementConfiguration stmtConfig = new StatementConfiguration(1, 2, 3, 4, 5); + QueryRunner queryRunner = new QueryRunner(stmtConfig); + queryRunner.prepareStatement(conn, "select 1"); + + verify(stmt).setFetchDirection(eq(1)); + verify(stmt).setFetchSize(eq(2)); + verify(stmt).setMaxFieldSize(eq(3)); + verify(stmt).setMaxRows(eq(4)); + verify(stmt).setQueryTimeout(eq(5)); + } + + // + // Execute tests + // + private void callGoodExecute(Connection conn) throws Exception { + when(call.execute()).thenReturn(false); + when(call.getUpdateCount()).thenReturn(3); + + when(meta.getParameterCount()).thenReturn(2); + int result = runner.execute(conn, "{call my_proc(?, ?)}", "unit", "test"); + + Assert.assertEquals(3, result); + + verify(call, times(1)).execute(); + verify(call, times(1)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + result = runner.execute(conn, "{call my_proc()}"); + + Assert.assertEquals(3, result); + + verify(call, times(2)).execute(); + verify(call, times(2)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test single OUT parameter + when(meta.getParameterCount()).thenReturn(1); + when(call.getObject(1)).thenReturn(42); + OutParameter<Integer> intParam = + new OutParameter<>(Types.INTEGER, Integer.class); + result = runner.execute(conn, "{?= call my_proc()}", intParam); + + Assert.assertEquals(42, intParam.getValue().intValue()); + Assert.assertEquals(3, result); + + verify(call, times(3)).execute(); + verify(call, times(3)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test OUT parameters with IN parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(4242); + intParam.setValue(null); + result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "unit", "test"); + + Assert.assertEquals(4242, intParam.getValue().intValue()); + Assert.assertEquals(3, result); + + verify(call, times(4)).execute(); + verify(call, times(4)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test INOUT parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(24); + when(call.getObject(3)).thenReturn("out"); + intParam.setValue(null); + OutParameter<String> stringParam = + new OutParameter<>(Types.VARCHAR, String.class, "in"); + result = runner.execute(conn, "{?= call my_proc(?, ?)}", intParam, "test", stringParam); + + Assert.assertEquals(24, intParam.getValue().intValue()); + Assert.assertEquals("out", stringParam.getValue()); + Assert.assertEquals(3, result); + + verify(call, times(5)).execute(); + verify(call, times(5)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + } + + private void callGoodExecute() throws Exception { + when(call.execute()).thenReturn(false); + when(call.getUpdateCount()).thenReturn(3); + + when(meta.getParameterCount()).thenReturn(2); + int result = runner.execute("{call my_proc(?, ?)}", "unit", "test"); + + Assert.assertEquals(3, result); + + verify(call, times(1)).execute(); + verify(call, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we do not close the connection + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + result = runner.execute("{call my_proc()}"); + + Assert.assertEquals(3, result); + + verify(call, times(2)).execute(); + verify(call, times(2)).close(); // make sure we closed the statement + verify(conn, times(2)).close(); // make sure we do not close the connection + + // Test single OUT parameter + when(meta.getParameterCount()).thenReturn(1); + when(call.getObject(1)).thenReturn(42); + OutParameter<Integer> intParam = + new OutParameter<>(Types.INTEGER, Integer.class); + result = runner.execute("{?= call my_proc()}", intParam); + + Assert.assertEquals(42, intParam.getValue().intValue()); + Assert.assertEquals(3, result); + + verify(call, times(3)).execute(); + verify(call, times(3)).close(); // make sure we closed the statement + verify(conn, times(3)).close(); // make sure we do not close the connection + + // Test OUT parameters with IN parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(4242); + intParam.setValue(null); + result = runner.execute("{?= call my_proc(?, ?)}", intParam, "unit", "test"); + + Assert.assertEquals(4242, intParam.getValue().intValue()); + Assert.assertEquals(3, result); + + verify(call, times(4)).execute(); + verify(call, times(4)).close(); // make sure we closed the statement + verify(conn, times(4)).close(); // make sure we do not close the connection + + // Test INOUT parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(24); + when(call.getObject(3)).thenReturn("out"); + intParam.setValue(null); + OutParameter<String> stringParam = + new OutParameter<>(Types.VARCHAR, String.class, "in"); + result = runner.execute("{?= call my_proc(?, ?)}", intParam, "test", stringParam); + + Assert.assertEquals(24, intParam.getValue().intValue()); + Assert.assertEquals("out", stringParam.getValue()); + Assert.assertEquals(3, result); + + verify(call, times(5)).execute(); + verify(call, times(5)).close(); // make sure we closed the statement + verify(conn, times(5)).close(); // make sure we do not close the connection + } + + @Test + public void testGoodExecute() throws Exception { + callGoodExecute(); + } + + @Test + public void testGoodExecutePmdTrue() throws Exception { + runner = new QueryRunner(true); + callGoodExecute(conn); + } + + @Test + public void testGoodExecuteDefaultConstructor() throws Exception { + runner = new QueryRunner(); + callGoodExecute(conn); + } + + // helper method for calling execute when an exception is expected + private void callExecuteWithException(Object... params) throws Exception { + boolean caught = false; + + try { + when(call.execute()).thenReturn(false); + when(meta.getParameterCount()).thenReturn(2); + runner.query("{call my_proc(?, ?)}", handler, params); + + } catch(SQLException e) { + caught = true; + } + + if(!caught) { + fail("Exception never thrown, but expected"); + } + } + + @Test + public void testNoParamsExecute() throws Exception { + callExecuteWithException(); + } + + @Test + public void testTooFewParamsExecute() throws Exception { + callExecuteWithException("unit"); + } + + @Test + public void testTooManyParamsExecute() throws Exception { + callExecuteWithException("unit", "test", "fail"); + } + + @Test(expected=SQLException.class) + public void testNullConnectionExecute() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + when(dataSource.getConnection()).thenReturn(null); + + runner.execute("{call my_proc(?, ?)}", "unit", "test"); + } + + @Test(expected=SQLException.class) + public void testNullSqlExecute() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.execute(null); + } + + @Test(expected=SQLException.class) + public void testNullHandlerExecute() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.execute("{call my_proc(?, ?)}"); + } + + @Test + public void testExecuteException() throws Exception { + doThrow(new SQLException()).when(stmt).execute(); + + callExecuteWithException(handler, "unit", "test"); + } + + // + // Execute with ResultSetHandler + // + + @Test + public void testExecuteWithMultipleResultSets() throws Exception { + when(call.execute()).thenReturn(true); + when(call.getMoreResults()).thenAnswer(new Answer<Boolean>() + { + int count = 1; + @Override + public Boolean answer(InvocationOnMock invocation) + { + return ++count <= 3; + } + }); + when(meta.getParameterCount()).thenReturn(0); + List<Object[]> objects = runner.execute("{call my_proc()}", handler); + + Assert.assertEquals(3, objects.size()); + verify(call, times(1)).execute(); + verify(results, times(3)).close(); + verify(call, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we close the connection + + } + + private void callGoodExecuteWithResultSet(Connection conn) throws Exception { + when(call.execute()).thenReturn(true); + + when(meta.getParameterCount()).thenReturn(2); + runner.execute(conn, "{call my_proc(?, ?)}", handler, "unit", "test"); + + verify(call, times(1)).execute(); + verify(results, times(1)).close(); + verify(call, times(1)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + runner.execute(conn, "{call my_proc()}", handler); + + verify(call, times(2)).execute(); + verify(results, times(2)).close(); + verify(call, times(2)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test single OUT parameter + when(meta.getParameterCount()).thenReturn(1); + when(call.getObject(1)).thenReturn(42); + OutParameter<Integer> intParam = + new OutParameter<>(Types.INTEGER, Integer.class); + runner.execute(conn, "{?= call my_proc()}", handler, intParam); + + Assert.assertEquals(42, intParam.getValue().intValue()); + + verify(call, times(3)).execute(); + verify(results, times(3)).close(); + verify(call, times(3)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test OUT parameters with IN parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(4242); + intParam.setValue(null); + runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "unit", "test"); + + Assert.assertEquals(4242, intParam.getValue().intValue()); + + verify(call, times(4)).execute(); + verify(results, times(4)).close(); + verify(call, times(4)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + + // Test INOUT parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(24); + when(call.getObject(3)).thenReturn("out"); + intParam.setValue(null); + OutParameter<String> stringParam = + new OutParameter<>(Types.VARCHAR, String.class, "in"); + runner.execute(conn, "{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam); + + Assert.assertEquals(24, intParam.getValue().intValue()); + Assert.assertEquals("out", stringParam.getValue()); + + verify(call, times(5)).execute(); + verify(results, times(5)).close(); + verify(call, times(5)).close(); // make sure we closed the statement + verify(conn, times(0)).close(); // make sure we do not close the connection + } + + private void callGoodExecuteWithResultSet() throws Exception { + when(call.execute()).thenReturn(true); + + when(meta.getParameterCount()).thenReturn(2); + runner.execute("{call my_proc(?, ?)}", handler, "unit", "test"); + + verify(call, times(1)).execute(); + verify(results, times(1)).close(); + verify(call, times(1)).close(); // make sure we closed the statement + verify(conn, times(1)).close(); // make sure we do not close the connection + + // call the other variation of query + when(meta.getParameterCount()).thenReturn(0); + runner.execute("{call my_proc()}", handler); + + verify(call, times(2)).execute(); + verify(results, times(2)).close(); + verify(call, times(2)).close(); // make sure we closed the statement + verify(conn, times(2)).close(); // make sure we do not close the connection + + // Test single OUT parameter + when(meta.getParameterCount()).thenReturn(1); + when(call.getObject(1)).thenReturn(42); + OutParameter<Integer> intParam = + new OutParameter<>(Types.INTEGER, Integer.class); + runner.execute("{?= call my_proc()}", handler, intParam); + + Assert.assertEquals(42, intParam.getValue().intValue()); + + verify(call, times(3)).execute(); + verify(results, times(3)).close(); + verify(call, times(3)).close(); // make sure we closed the statement + verify(conn, times(3)).close(); // make sure we do not close the connection + + // Test OUT parameters with IN parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(4242); + intParam.setValue(null); + runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "unit", "test"); + + Assert.assertEquals(4242, intParam.getValue().intValue()); + + verify(call, times(4)).execute(); + verify(results, times(4)).close(); + verify(call, times(4)).close(); // make sure we closed the statement + verify(conn, times(4)).close(); // make sure we do not close the connection + + // Test INOUT parameters + when(meta.getParameterCount()).thenReturn(3); + when(call.getObject(1)).thenReturn(24); + when(call.getObject(3)).thenReturn("out"); + intParam.setValue(null); + OutParameter<String> stringParam = + new OutParameter<>(Types.VARCHAR, String.class, "in"); + runner.execute("{?= call my_proc(?, ?)}", handler, intParam, "test", stringParam); + + Assert.assertEquals(24, intParam.getValue().intValue()); + Assert.assertEquals("out", stringParam.getValue()); + + verify(call, times(5)).execute(); + verify(results, times(5)).close(); + verify(call, times(5)).close(); // make sure we closed the statement + verify(conn, times(5)).close(); // make sure we do not close the connection + } + + @Test + public void testGoodExecuteWithResultSet() throws Exception { + callGoodExecuteWithResultSet(); + } + + @Test + public void testGoodExecuteWithResultSetPmdTrue() throws Exception { + runner = new QueryRunner(true); + callGoodExecuteWithResultSet(conn); + } + + @Test + public void testGoodExecuteWithResultSetDefaultConstructor() throws Exception { + runner = new QueryRunner(); + callGoodExecuteWithResultSet(conn); + } + + // helper method for calling execute when an exception is expected + private void callExecuteWithResultSetWithException(Object... params) throws Exception { + boolean caught = false; + + try { + when(call.execute()).thenReturn(true); + when(meta.getParameterCount()).thenReturn(2); + runner.query("{call my_proc(?, ?)}", handler, params); + + } catch(SQLException e) { + caught = true; + } + + if(!caught) { + fail("Exception never thrown, but expected"); + } + } + + @Test + public void testNoParamsExecuteWithResultSet() throws Exception { + callExecuteWithResultSetWithException(); + } + + @Test + public void testTooFewParamsExecuteWithResultSet() throws Exception { + callExecuteWithResultSetWithException("unit"); + } + + @Test + public void testTooManyParamsExecuteWithResultSet() throws Exception { + callExecuteWithResultSetWithException("unit", "test", "fail"); + } + + @Test(expected=SQLException.class) + public void testNullConnectionExecuteWithResultSet() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + when(dataSource.getConnection()).thenReturn(null); + + runner.execute("{call my_proc(?, ?)}", handler, "unit", "test"); + } + + @Test(expected=SQLException.class) + public void testNullSqlExecuteWithResultSet() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.execute(null, handler); + } + + @Test(expected=SQLException.class) + public void testNullHandlerExecuteWithResultSet() throws Exception { + when(meta.getParameterCount()).thenReturn(2); + + runner.execute("{call my_proc(?, ?)}", (ResultSetHandler)null); + } + + @Test + public void testExecuteWithResultSetException() throws Exception { + doThrow(new SQLException()).when(stmt).execute(); + + callExecuteWithResultSetWithException(handler, "unit", "test"); + } + + // + // Random tests + // + class MyBean { + private int a; + private double b; + private String c; + + public int getA() { return a; } + public void setA(int a) { this.a = a; } + public double getB() { return b; } + public void setB(double b) { this.b = b; } + public String getC() { return c; } + public void setC(String c) { this.c = c; } + } + + @Test + public void testFillStatementWithBean() throws Exception { + MyBean bean = new MyBean(); + when(meta.getParameterCount()).thenReturn(3); + runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", "c" }); + } + + @Test(expected=NullPointerException.class) + public void testFillStatementWithBeanNullNames() throws Exception { + MyBean bean = new MyBean(); + when(meta.getParameterCount()).thenReturn(3); + runner.fillStatementWithBean(stmt, bean, new String[] { "a", "b", null }); + } + + @Test(expected=SQLException.class) + public void testBadPrepareConnection() throws Exception { + runner = new QueryRunner(); + runner.update("update blah set unit = test"); + } +} http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java index 6eb7135..6d5e2cb 100644 --- a/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java +++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanHandlerTest.java @@ -28,7 +28,7 @@ import org.apache.commons.dbutils.TestBean; public class BeanHandlerTest extends BaseTestCase { public void testHandle() throws SQLException { - ResultSetHandler<TestBean> h = new BeanHandler<TestBean>(TestBean.class); + ResultSetHandler<TestBean> h = new BeanHandler<>(TestBean.class); TestBean results = h.handle(this.rs); assertNotNull(results); @@ -39,7 +39,7 @@ public class BeanHandlerTest extends BaseTestCase { } public void testEmptyResultSetHandle() throws SQLException { - ResultSetHandler<TestBean> h = new BeanHandler<TestBean>(TestBean.class); + ResultSetHandler<TestBean> h = new BeanHandler<>(TestBean.class); TestBean results = h.handle(this.emptyResultSet); assertNull(results); http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java index ef3a9e5..d5b293b 100644 --- a/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java +++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanListHandlerTest.java @@ -30,7 +30,7 @@ import org.apache.commons.dbutils.TestBean; public class BeanListHandlerTest extends BaseTestCase { public void testHandle() throws SQLException { - ResultSetHandler<List<TestBean>> h = new BeanListHandler<TestBean>(TestBean.class); + ResultSetHandler<List<TestBean>> h = new BeanListHandler<>(TestBean.class); List<TestBean> results = h.handle(this.rs); assertNotNull(results); @@ -57,7 +57,7 @@ public class BeanListHandlerTest extends BaseTestCase { } public void testEmptyResultSetHandle() throws SQLException { - ResultSetHandler<List<TestBean>> h = new BeanListHandler<TestBean>(TestBean.class); + ResultSetHandler<List<TestBean>> h = new BeanListHandler<>(TestBean.class); List<TestBean> results = h.handle(this.emptyResultSet); assertNotNull(results); http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/d484a72e/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java b/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java index 09ae157..60d505a 100644 --- a/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java +++ b/src/test/java/org/apache/commons/dbutils/handlers/BeanMapHandlerTest.java @@ -57,32 +57,32 @@ public class BeanMapHandlerTest { @Test public void testBeanMapHandlerClassOfV() throws Exception { - bmh = new BeanMapHandler<Long, TestBean>(TestBean.class); + bmh = new BeanMapHandler<>(TestBean.class); handle(); } @Test public void testBeanMapHandlerClassOfVRowProcessor() throws Exception { - bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, rp); + bmh = new BeanMapHandler<>(TestBean.class, rp); handle(); } @Test public void testBeanMapHandlerClassOfVInt() throws Exception { - bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, 2); + bmh = new BeanMapHandler<>(TestBean.class, 2); handle(); } @Test public void testBeanMapHandlerClassOfVString() throws Exception { - bmh = new BeanMapHandler<Long, TestBean>(TestBean.class, "id"); + bmh = new BeanMapHandler<>(TestBean.class, "id"); handle(); } @Test public void testEmptyResultSet() throws Exception { when(Boolean.valueOf(rs.next())).thenReturn(Boolean.FALSE); - bmh = new BeanMapHandler<Long, TestBean>(TestBean.class); + bmh = new BeanMapHandler<>(TestBean.class); res = bmh.handle(rs); assertNull(res.get(Long.valueOf(23L))); }
