You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by gg...@apache.org on 2018/07/13 00:25:57 UTC
[17/50] [abbrv] commons-dbcp git commit: [DBCP-504] Increase test
coverage. Closes #13.
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestDelegatingResultSet.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestDelegatingResultSet.java b/src/test/java/org/apache/commons/dbcp2/TestDelegatingResultSet.java
new file mode 100644
index 0000000..f677fde
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbcp2/TestDelegatingResultSet.java
@@ -0,0 +1,1835 @@
+/*
+ * 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.dbcp2;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Test;
+
+/**
+ * Tests for DelegatingResultSet.
+ */
+@SuppressWarnings({ "deprecation", "unchecked", "rawtypes" }) // BigDecimal methods, and casting for mocks
+public class TestDelegatingResultSet {
+
+ private TesterConnection testConn;
+ private DelegatingConnection<Connection> conn;
+ private ResultSet rs;
+ private DelegatingResultSet delegate;
+
+ @Before
+ public void setUp() {
+ testConn = new TesterConnection("foo", "bar");
+ conn = new DelegatingConnection<Connection>(testConn);
+ rs = mock(ResultSet.class);
+ delegate = (DelegatingResultSet) DelegatingResultSet.wrapResultSet((Connection) conn, rs);
+ }
+
+ @Test
+ public void testAbsolutes() throws Exception {
+ try {
+ delegate.absolute(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).absolute(1);
+ }
+
+ @Test
+ public void testAbsoluteInteger() throws Exception {
+ try {
+ delegate.absolute(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).absolute(1);
+ }
+
+ @Test
+ public void testAfterLast() throws Exception {
+ try {
+ delegate.afterLast();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).afterLast();
+ }
+
+ @Test
+ public void testBeforeFirst() throws Exception {
+ try {
+ delegate.beforeFirst();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).beforeFirst();
+ }
+
+ @Test
+ public void testCancelRowUpdates() throws Exception {
+ try {
+ delegate.cancelRowUpdates();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).cancelRowUpdates();
+ }
+
+ @Test
+ public void testClearWarnings() throws Exception {
+ try {
+ delegate.clearWarnings();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).clearWarnings();
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ try {
+ delegate.close();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).close();
+ }
+
+ @Test
+ public void testDeleteRow() throws Exception {
+ try {
+ delegate.deleteRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).deleteRow();
+ }
+
+ @Test
+ public void testFindColumnString() throws Exception {
+ try {
+ delegate.findColumn("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).findColumn("foo");
+ }
+
+ @Test
+ public void testFirst() throws Exception {
+ try {
+ delegate.first();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).first();
+ }
+
+ @Test
+ public void testGetArrayInteger() throws Exception {
+ try {
+ delegate.getArray(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getArray(1);
+ }
+
+ @Test
+ public void testGetArrayString() throws Exception {
+ try {
+ delegate.getArray("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getArray("foo");
+ }
+
+ @Test
+ public void testGetAsciiStreamInteger() throws Exception {
+ try {
+ delegate.getAsciiStream(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getAsciiStream(1);
+ }
+
+ @Test
+ public void testGetAsciiStreamString() throws Exception {
+ try {
+ delegate.getAsciiStream("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getAsciiStream("foo");
+ }
+
+ // FIXME: this appears to be a bug
+ @Ignore
+ @Test
+ public void testGetBigDecimalStringInteger() throws Exception {
+ try {
+ delegate.getBigDecimal("foo", 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBigDecimal("foo", 1);
+ }
+
+ // FIXME: this appears to be a bug
+ @Ignore
+ @Test
+ public void testGetBigDecimalIntegerInteger() throws Exception {
+ try {
+ delegate.getBigDecimal(1, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBigDecimal(1, 1);
+ }
+
+ @Test
+ public void testGetBigDecimalInteger() throws Exception {
+ try {
+ delegate.getBigDecimal(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBigDecimal(1);
+ }
+
+ @Test
+ public void testGetBigDecimalString() throws Exception {
+ try {
+ delegate.getBigDecimal("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBigDecimal("foo");
+ }
+
+ @Test
+ public void testGetBinaryStreamString() throws Exception {
+ try {
+ delegate.getBinaryStream("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBinaryStream("foo");
+ }
+
+ @Test
+ public void testGetBinaryStreamInteger() throws Exception {
+ try {
+ delegate.getBinaryStream(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBinaryStream(1);
+ }
+
+ @Test
+ public void testGetBlobString() throws Exception {
+ try {
+ delegate.getBlob("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBlob("foo");
+ }
+
+ @Test
+ public void testGetBlobInteger() throws Exception {
+ try {
+ delegate.getBlob(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBlob(1);
+ }
+
+ @Test
+ public void testGetBooleanInteger() throws Exception {
+ try {
+ delegate.getBoolean(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBoolean(1);
+ }
+
+ @Test
+ public void testGetBooleanString() throws Exception {
+ try {
+ delegate.getBoolean("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBoolean("foo");
+ }
+
+ @Test
+ public void testGetByteString() throws Exception {
+ try {
+ delegate.getByte("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getByte("foo");
+ }
+
+ @Test
+ public void testGetByteInteger() throws Exception {
+ try {
+ delegate.getByte(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getByte(1);
+ }
+
+ @Test
+ public void testGetBytesInteger() throws Exception {
+ try {
+ delegate.getBytes(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBytes(1);
+ }
+
+ @Test
+ public void testGetBytesString() throws Exception {
+ try {
+ delegate.getBytes("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getBytes("foo");
+ }
+
+ @Test
+ public void testGetCharacterStreamString() throws Exception {
+ try {
+ delegate.getCharacterStream("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getCharacterStream("foo");
+ }
+
+ @Test
+ public void testGetCharacterStreamInteger() throws Exception {
+ try {
+ delegate.getCharacterStream(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getCharacterStream(1);
+ }
+
+ @Test
+ public void testGetClobInteger() throws Exception {
+ try {
+ delegate.getClob(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getClob(1);
+ }
+
+ @Test
+ public void testGetClobString() throws Exception {
+ try {
+ delegate.getClob("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getClob("foo");
+ }
+
+ @Test
+ public void testGetConcurrency() throws Exception {
+ try {
+ delegate.getConcurrency();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getConcurrency();
+ }
+
+ @Test
+ public void testGetCursorName() throws Exception {
+ try {
+ delegate.getCursorName();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getCursorName();
+ }
+
+ @Test
+ public void testGetDateInteger() throws Exception {
+ try {
+ delegate.getDate(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDate(1);
+ }
+
+ @Test
+ public void testGetDateString() throws Exception {
+ try {
+ delegate.getDate("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDate("foo");
+ }
+
+ @Test
+ public void testGetDateStringCalendar() throws Exception {
+ try {
+ delegate.getDate("foo", (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDate("foo", (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetDateIntegerCalendar() throws Exception {
+ try {
+ delegate.getDate(1, (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDate(1, (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetDoubleString() throws Exception {
+ try {
+ delegate.getDouble("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDouble("foo");
+ }
+
+ @Test
+ public void testGetDoubleInteger() throws Exception {
+ try {
+ delegate.getDouble(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getDouble(1);
+ }
+
+ @Test
+ public void testGetFetchDirection() throws Exception {
+ try {
+ delegate.getFetchDirection();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getFetchDirection();
+ }
+
+ @Test
+ public void testGetFetchSize() throws Exception {
+ try {
+ delegate.getFetchSize();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getFetchSize();
+ }
+
+ @Test
+ public void testGetFloatString() throws Exception {
+ try {
+ delegate.getFloat("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getFloat("foo");
+ }
+
+ @Test
+ public void testGetFloatInteger() throws Exception {
+ try {
+ delegate.getFloat(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getFloat(1);
+ }
+
+ @Test
+ public void testGetHoldability() throws Exception {
+ try {
+ delegate.getHoldability();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getHoldability();
+ }
+
+ @Test
+ public void testGetIntInteger() throws Exception {
+ try {
+ delegate.getInt(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getInt(1);
+ }
+
+ @Test
+ public void testGetIntString() throws Exception {
+ try {
+ delegate.getInt("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getInt("foo");
+ }
+
+ @Test
+ public void testGetLongInteger() throws Exception {
+ try {
+ delegate.getLong(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getLong(1);
+ }
+
+ @Test
+ public void testGetLongString() throws Exception {
+ try {
+ delegate.getLong("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getLong("foo");
+ }
+
+ @Test
+ public void testGetMetaData() throws Exception {
+ try {
+ delegate.getMetaData();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getMetaData();
+ }
+
+ @Test
+ public void testGetNCharacterStreamString() throws Exception {
+ try {
+ delegate.getNCharacterStream("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNCharacterStream("foo");
+ }
+
+ @Test
+ public void testGetNCharacterStreamInteger() throws Exception {
+ try {
+ delegate.getNCharacterStream(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNCharacterStream(1);
+ }
+
+ @Test
+ public void testGetNClobString() throws Exception {
+ try {
+ delegate.getNClob("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNClob("foo");
+ }
+
+ @Test
+ public void testGetNClobInteger() throws Exception {
+ try {
+ delegate.getNClob(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNClob(1);
+ }
+
+ @Test
+ public void testGetNStringString() throws Exception {
+ try {
+ delegate.getNString("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNString("foo");
+ }
+
+ @Test
+ public void testGetNStringInteger() throws Exception {
+ try {
+ delegate.getNString(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getNString(1);
+ }
+
+ @Test
+ public void testGetObjectIntegerClass() throws Exception {
+ try {
+ delegate.getObject(1, Object.class);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject(1, Object.class);
+ }
+
+ @Test
+ public void testGetObjectIntegerMap() throws Exception {
+ try {
+ delegate.getObject(1, (java.util.Map) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject(1, (java.util.Map) null);
+ }
+
+ @Test
+ public void testGetObjectString() throws Exception {
+ try {
+ delegate.getObject("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject("foo");
+ }
+
+ @Test
+ public void testGetObjectStringMap() throws Exception {
+ try {
+ delegate.getObject("foo", (java.util.Map) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject("foo", (java.util.Map) null);
+ }
+
+ @Test
+ public void testGetObjectInteger() throws Exception {
+ try {
+ delegate.getObject(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject(1);
+ }
+
+ @Test
+ public void testGetObjectStringClass() throws Exception {
+ try {
+ delegate.getObject("foo", Object.class);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getObject("foo", Object.class);
+ }
+
+ @Test
+ public void testGetRefInteger() throws Exception {
+ try {
+ delegate.getRef(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getRef(1);
+ }
+
+ @Test
+ public void testGetRefString() throws Exception {
+ try {
+ delegate.getRef("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getRef("foo");
+ }
+
+ @Test
+ public void testGetRow() throws Exception {
+ try {
+ delegate.getRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getRow();
+ }
+
+ @Test
+ public void testGetRowIdString() throws Exception {
+ try {
+ delegate.getRowId("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getRowId("foo");
+ }
+
+ @Test
+ public void testGetRowIdInteger() throws Exception {
+ try {
+ delegate.getRowId(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getRowId(1);
+ }
+
+ @Test
+ public void testGetSQLXMLString() throws Exception {
+ try {
+ delegate.getSQLXML("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getSQLXML("foo");
+ }
+
+ @Test
+ public void testGetSQLXMLInteger() throws Exception {
+ try {
+ delegate.getSQLXML(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getSQLXML(1);
+ }
+
+ @Test
+ public void testGetShortInteger() throws Exception {
+ try {
+ delegate.getShort(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getShort(1);
+ }
+
+ @Test
+ public void testGetShortString() throws Exception {
+ try {
+ delegate.getShort("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getShort("foo");
+ }
+
+ /**
+ * This method is a bit special. It actually calls statement in the
+ * {@link DelegatingResultSet} object itself, instead of calling in the
+ * underlying {@link ResultSet}.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testGetStatement() throws Exception {
+ try {
+ delegate.getStatement();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(0)).getStatement();
+ }
+
+ @Test
+ public void testGetStringInteger() throws Exception {
+ try {
+ delegate.getString(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getString(1);
+ }
+
+ @Test
+ public void testGetStringString() throws Exception {
+ try {
+ delegate.getString("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getString("foo");
+ }
+
+ @Test
+ public void testGetTimeInteger() throws Exception {
+ try {
+ delegate.getTime(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTime(1);
+ }
+
+ @Test
+ public void testGetTimeIntegerCalendar() throws Exception {
+ try {
+ delegate.getTime(1, (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTime(1, (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetTimeString() throws Exception {
+ try {
+ delegate.getTime("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTime("foo");
+ }
+
+ @Test
+ public void testGetTimeStringCalendar() throws Exception {
+ try {
+ delegate.getTime("foo", (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTime("foo", (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetTimestampString() throws Exception {
+ try {
+ delegate.getTimestamp("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTimestamp("foo");
+ }
+
+ @Test
+ public void testGetTimestampIntegerCalendar() throws Exception {
+ try {
+ delegate.getTimestamp(1, (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTimestamp(1, (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetTimestampInteger() throws Exception {
+ try {
+ delegate.getTimestamp(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTimestamp(1);
+ }
+
+ @Test
+ public void testGetTimestampStringCalendar() throws Exception {
+ try {
+ delegate.getTimestamp("foo", (java.util.Calendar) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getTimestamp("foo", (java.util.Calendar) null);
+ }
+
+ @Test
+ public void testGetType() throws Exception {
+ try {
+ delegate.getType();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getType();
+ }
+
+ @Test
+ public void testGetURLInteger() throws Exception {
+ try {
+ delegate.getURL(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getURL(1);
+ }
+
+ @Test
+ public void testGetURLString() throws Exception {
+ try {
+ delegate.getURL("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getURL("foo");
+ }
+
+ @Test
+ public void testGetUnicodeStreamString() throws Exception {
+ try {
+ delegate.getUnicodeStream("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getUnicodeStream("foo");
+ }
+
+ @Test
+ public void testGetUnicodeStreamInteger() throws Exception {
+ try {
+ delegate.getUnicodeStream(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getUnicodeStream(1);
+ }
+
+ @Test
+ public void testGetWarnings() throws Exception {
+ try {
+ delegate.getWarnings();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).getWarnings();
+ }
+
+ @Test
+ public void testInsertRow() throws Exception {
+ try {
+ delegate.insertRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).insertRow();
+ }
+
+ @Test
+ public void testIsAfterLast() throws Exception {
+ try {
+ delegate.isAfterLast();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).isAfterLast();
+ }
+
+ @Test
+ public void testIsBeforeFirst() throws Exception {
+ try {
+ delegate.isBeforeFirst();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).isBeforeFirst();
+ }
+
+ @Test
+ public void testIsClosed() throws Exception {
+ try {
+ delegate.isClosed();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).isClosed();
+ }
+
+ @Test
+ public void testIsFirst() throws Exception {
+ try {
+ delegate.isFirst();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).isFirst();
+ }
+
+ @Test
+ public void testIsLast() throws Exception {
+ try {
+ delegate.isLast();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).isLast();
+ }
+
+ @Test
+ public void testLast() throws Exception {
+ try {
+ delegate.last();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).last();
+ }
+
+ @Test
+ public void testMoveToCurrentRow() throws Exception {
+ try {
+ delegate.moveToCurrentRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).moveToCurrentRow();
+ }
+
+ @Test
+ public void testMoveToInsertRow() throws Exception {
+ try {
+ delegate.moveToInsertRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).moveToInsertRow();
+ }
+
+ @Test
+ public void testNext() throws Exception {
+ try {
+ delegate.next();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).next();
+ }
+
+ @Test
+ public void testPrevious() throws Exception {
+ try {
+ delegate.previous();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).previous();
+ }
+
+ @Test
+ public void testRefreshRow() throws Exception {
+ try {
+ delegate.refreshRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).refreshRow();
+ }
+
+ @Test
+ public void testRelativeInteger() throws Exception {
+ try {
+ delegate.relative(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).relative(1);
+ }
+
+ @Test
+ public void testRowDeleted() throws Exception {
+ try {
+ delegate.rowDeleted();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).rowDeleted();
+ }
+
+ @Test
+ public void testRowInserted() throws Exception {
+ try {
+ delegate.rowInserted();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).rowInserted();
+ }
+
+ @Test
+ public void testRowUpdated() throws Exception {
+ try {
+ delegate.rowUpdated();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).rowUpdated();
+ }
+
+ @Test
+ public void testSetFetchDirectionInteger() throws Exception {
+ try {
+ delegate.setFetchDirection(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).setFetchDirection(1);
+ }
+
+ @Test
+ public void testSetFetchSizeInteger() throws Exception {
+ try {
+ delegate.setFetchSize(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).setFetchSize(1);
+ }
+
+ @Test
+ public void testUpdateArrayStringArray() throws Exception {
+ try {
+ delegate.updateArray("foo", (java.sql.Array) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateArray("foo", (java.sql.Array) null);
+ }
+
+ @Test
+ public void testUpdateArrayIntegerArray() throws Exception {
+ try {
+ delegate.updateArray(1, (java.sql.Array) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateArray(1, (java.sql.Array) null);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamStringInputStreamInteger() throws Exception {
+ try {
+ delegate.updateAsciiStream("foo", (java.io.InputStream) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream("foo", (java.io.InputStream) null, 1);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamStringInputStreamLong() throws Exception {
+ try {
+ delegate.updateAsciiStream("foo", (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream("foo", (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamIntegerInputStreamInteger() throws Exception {
+ try {
+ delegate.updateAsciiStream(1, (java.io.InputStream) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream(1, (java.io.InputStream) null, 1);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamIntegerInputStream() throws Exception {
+ try {
+ delegate.updateAsciiStream(1, (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream(1, (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamIntegerInputStreamLong() throws Exception {
+ try {
+ delegate.updateAsciiStream(1, (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream(1, (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateAsciiStreamStringInputStream() throws Exception {
+ try {
+ delegate.updateAsciiStream("foo", (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateAsciiStream("foo", (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateBigDecimalStringBigDecimal() throws Exception {
+ try {
+ delegate.updateBigDecimal("foo", java.math.BigDecimal.valueOf(1.0d));
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBigDecimal("foo", java.math.BigDecimal.valueOf(1.0d));
+ }
+
+ @Test
+ public void testUpdateBigDecimalIntegerBigDecimal() throws Exception {
+ try {
+ delegate.updateBigDecimal(1, java.math.BigDecimal.valueOf(1.0d));
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBigDecimal(1, java.math.BigDecimal.valueOf(1.0d));
+ }
+
+ @Test
+ public void testUpdateBinaryStreamIntegerInputStream() throws Exception {
+ try {
+ delegate.updateBinaryStream(1, (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream(1, (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateBinaryStreamIntegerInputStreamInteger() throws Exception {
+ try {
+ delegate.updateBinaryStream(1, (java.io.InputStream) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream(1, (java.io.InputStream) null, 1);
+ }
+
+ @Test
+ public void testUpdateBinaryStreamIntegerInputStreamLong() throws Exception {
+ try {
+ delegate.updateBinaryStream(1, (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream(1, (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateBinaryStreamStringInputStreamLong() throws Exception {
+ try {
+ delegate.updateBinaryStream("foo", (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream("foo", (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateBinaryStreamStringInputStreamInteger() throws Exception {
+ try {
+ delegate.updateBinaryStream("foo", (java.io.InputStream) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream("foo", (java.io.InputStream) null, 1);
+ }
+
+ @Test
+ public void testUpdateBinaryStreamStringInputStream() throws Exception {
+ try {
+ delegate.updateBinaryStream("foo", (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBinaryStream("foo", (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateBlobIntegerBlob() throws Exception {
+ try {
+ delegate.updateBlob(1, (java.sql.Blob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob(1, (java.sql.Blob) null);
+ }
+
+ @Test
+ public void testUpdateBlobStringInputStream() throws Exception {
+ try {
+ delegate.updateBlob("foo", (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob("foo", (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateBlobStringBlob() throws Exception {
+ try {
+ delegate.updateBlob("foo", (java.sql.Blob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob("foo", (java.sql.Blob) null);
+ }
+
+ @Test
+ public void testUpdateBlobStringInputStreamLong() throws Exception {
+ try {
+ delegate.updateBlob("foo", (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob("foo", (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateBlobIntegerInputStream() throws Exception {
+ try {
+ delegate.updateBlob(1, (java.io.InputStream) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob(1, (java.io.InputStream) null);
+ }
+
+ @Test
+ public void testUpdateBlobIntegerInputStreamLong() throws Exception {
+ try {
+ delegate.updateBlob(1, (java.io.InputStream) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBlob(1, (java.io.InputStream) null, 1l);
+ }
+
+ @Test
+ public void testUpdateBooleanIntegerBoolean() throws Exception {
+ try {
+ delegate.updateBoolean(1, Boolean.TRUE);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBoolean(1, Boolean.TRUE);
+ }
+
+ @Test
+ public void testUpdateBooleanStringBoolean() throws Exception {
+ try {
+ delegate.updateBoolean("foo", Boolean.TRUE);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBoolean("foo", Boolean.TRUE);
+ }
+
+ @Test
+ public void testUpdateByteStringByte() throws Exception {
+ try {
+ delegate.updateByte("foo", (byte) 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateByte("foo", (byte) 1);
+ }
+
+ @Test
+ public void testUpdateByteIntegerByte() throws Exception {
+ try {
+ delegate.updateByte(1, (byte) 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateByte(1, (byte) 1);
+ }
+
+ @Test
+ public void testUpdateBytesIntegerByteArray() throws Exception {
+ try {
+ delegate.updateBytes(1, new byte[] { 1 });
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBytes(1, new byte[] { 1 });
+ }
+
+ @Test
+ public void testUpdateBytesStringByteArray() throws Exception {
+ try {
+ delegate.updateBytes("foo", new byte[] { 1 });
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateBytes("foo", new byte[] { 1 });
+ }
+
+ @Test
+ public void testUpdateCharacterStreamIntegerReaderInteger() throws Exception {
+ try {
+ delegate.updateCharacterStream(1, (java.io.StringReader) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream(1, (java.io.StringReader) null, 1);
+ }
+
+ @Test
+ public void testUpdateCharacterStreamIntegerReaderLong() throws Exception {
+ try {
+ delegate.updateCharacterStream(1, (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream(1, (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateCharacterStreamStringReaderLong() throws Exception {
+ try {
+ delegate.updateCharacterStream("foo", (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream("foo", (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateCharacterStreamIntegerReader() throws Exception {
+ try {
+ delegate.updateCharacterStream(1, (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream(1, (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateCharacterStreamStringReader() throws Exception {
+ try {
+ delegate.updateCharacterStream("foo", (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream("foo", (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateCharacterStreamStringReaderInteger() throws Exception {
+ try {
+ delegate.updateCharacterStream("foo", (java.io.StringReader) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateCharacterStream("foo", (java.io.StringReader) null, 1);
+ }
+
+ @Test
+ public void testUpdateClobStringReaderLong() throws Exception {
+ try {
+ delegate.updateClob("foo", (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob("foo", (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateClobStringReader() throws Exception {
+ try {
+ delegate.updateClob("foo", (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob("foo", (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateClobIntegerReader() throws Exception {
+ try {
+ delegate.updateClob(1, (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob(1, (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateClobIntegerClob() throws Exception {
+ try {
+ delegate.updateClob(1, (java.sql.Clob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob(1, (java.sql.Clob) null);
+ }
+
+ @Test
+ public void testUpdateClobStringClob() throws Exception {
+ try {
+ delegate.updateClob("foo", (java.sql.Clob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob("foo", (java.sql.Clob) null);
+ }
+
+ @Test
+ public void testUpdateClobIntegerReaderLong() throws Exception {
+ try {
+ delegate.updateClob(1, (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateClob(1, (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateDateIntegerSqlDate() throws Exception {
+ try {
+ delegate.updateDate(1, new java.sql.Date(1529827548745l));
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateDate(1, new java.sql.Date(1529827548745l));
+ }
+
+ @Test
+ public void testUpdateDateStringSqlDate() throws Exception {
+ try {
+ delegate.updateDate("foo", new java.sql.Date(1529827548745l));
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateDate("foo", new java.sql.Date(1529827548745l));
+ }
+
+ @Test
+ public void testUpdateDoubleIntegerDouble() throws Exception {
+ try {
+ delegate.updateDouble(1, 1.0d);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateDouble(1, 1.0d);
+ }
+
+ @Test
+ public void testUpdateDoubleStringDouble() throws Exception {
+ try {
+ delegate.updateDouble("foo", 1.0d);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateDouble("foo", 1.0d);
+ }
+
+ @Test
+ public void testUpdateFloatStringFloat() throws Exception {
+ try {
+ delegate.updateFloat("foo", 1.0f);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateFloat("foo", 1.0f);
+ }
+
+ @Test
+ public void testUpdateFloatIntegerFloat() throws Exception {
+ try {
+ delegate.updateFloat(1, 1.0f);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateFloat(1, 1.0f);
+ }
+
+ @Test
+ public void testUpdateIntStringInteger() throws Exception {
+ try {
+ delegate.updateInt("foo", 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateInt("foo", 1);
+ }
+
+ @Test
+ public void testUpdateIntIntegerInteger() throws Exception {
+ try {
+ delegate.updateInt(1, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateInt(1, 1);
+ }
+
+ @Test
+ public void testUpdateLongStringLong() throws Exception {
+ try {
+ delegate.updateLong("foo", 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateLong("foo", 1l);
+ }
+
+ @Test
+ public void testUpdateLongIntegerLong() throws Exception {
+ try {
+ delegate.updateLong(1, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateLong(1, 1l);
+ }
+
+ @Test
+ public void testUpdateNCharacterStreamStringReader() throws Exception {
+ try {
+ delegate.updateNCharacterStream("foo", (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNCharacterStream("foo", (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateNCharacterStreamIntegerReader() throws Exception {
+ try {
+ delegate.updateNCharacterStream(1, (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNCharacterStream(1, (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateNCharacterStreamStringReaderLong() throws Exception {
+ try {
+ delegate.updateNCharacterStream("foo", (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNCharacterStream("foo", (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateNCharacterStreamIntegerReaderLong() throws Exception {
+ try {
+ delegate.updateNCharacterStream(1, (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNCharacterStream(1, (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateNClobStringNClob() throws Exception {
+ try {
+ delegate.updateNClob("foo", (java.sql.NClob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob("foo", (java.sql.NClob) null);
+ }
+
+ @Test
+ public void testUpdateNClobIntegerReaderLong() throws Exception {
+ try {
+ delegate.updateNClob(1, (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob(1, (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateNClobIntegerNClob() throws Exception {
+ try {
+ delegate.updateNClob(1, (java.sql.NClob) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob(1, (java.sql.NClob) null);
+ }
+
+ @Test
+ public void testUpdateNClobIntegerReader() throws Exception {
+ try {
+ delegate.updateNClob(1, (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob(1, (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateNClobStringReaderLong() throws Exception {
+ try {
+ delegate.updateNClob("foo", (java.io.StringReader) null, 1l);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob("foo", (java.io.StringReader) null, 1l);
+ }
+
+ @Test
+ public void testUpdateNClobStringReader() throws Exception {
+ try {
+ delegate.updateNClob("foo", (java.io.StringReader) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNClob("foo", (java.io.StringReader) null);
+ }
+
+ @Test
+ public void testUpdateNStringIntegerString() throws Exception {
+ try {
+ delegate.updateNString(1, "foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNString(1, "foo");
+ }
+
+ @Test
+ public void testUpdateNStringStringString() throws Exception {
+ try {
+ delegate.updateNString("foo", "foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNString("foo", "foo");
+ }
+
+ @Test
+ public void testUpdateNullInteger() throws Exception {
+ try {
+ delegate.updateNull(1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNull(1);
+ }
+
+ @Test
+ public void testUpdateNullString() throws Exception {
+ try {
+ delegate.updateNull("foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateNull("foo");
+ }
+
+ @Test
+ public void testUpdateObjectStringObjectSQLType() throws Exception {
+ try {
+ delegate.updateObject("foo", System.err, (java.sql.SQLType) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject("foo", System.err, (java.sql.SQLType) null);
+ }
+
+ @Test
+ public void testUpdateObjectStringObjectSQLTypeInteger() throws Exception {
+ try {
+ delegate.updateObject("foo", System.err, (java.sql.SQLType) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject("foo", System.err, (java.sql.SQLType) null, 1);
+ }
+
+ @Test
+ public void testUpdateObjectIntegerObject() throws Exception {
+ try {
+ delegate.updateObject(1, System.err);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject(1, System.err);
+ }
+
+ @Test
+ public void testUpdateObjectIntegerObjectSQLTypeInteger() throws Exception {
+ try {
+ delegate.updateObject(1, System.err, (java.sql.SQLType) null, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject(1, System.err, (java.sql.SQLType) null, 1);
+ }
+
+ // FIXME this appears to be a bug
+ @Ignore
+ @Test
+ public void testUpdateObjectStringObjectInteger() throws Exception {
+ try {
+ delegate.updateObject("foo", System.err, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject("foo", System.err, 1);
+ }
+
+ // FIXME: this appears to be a bug
+ @Ignore
+ @Test
+ public void testUpdateObjectIntegerObjectInteger() throws Exception {
+ try {
+ delegate.updateObject(1, System.err, 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject(1, System.err, 1);
+ }
+
+ @Test
+ public void testUpdateObjectStringObject() throws Exception {
+ try {
+ delegate.updateObject("foo", System.err);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject("foo", System.err);
+ }
+
+ @Test
+ public void testUpdateObjectIntegerObjectSQLType() throws Exception {
+ try {
+ delegate.updateObject(1, System.err, (java.sql.SQLType) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateObject(1, System.err, (java.sql.SQLType) null);
+ }
+
+ @Test
+ public void testUpdateRefIntegerRef() throws Exception {
+ try {
+ delegate.updateRef(1, (java.sql.Ref) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateRef(1, (java.sql.Ref) null);
+ }
+
+ @Test
+ public void testUpdateRefStringRef() throws Exception {
+ try {
+ delegate.updateRef("foo", (java.sql.Ref) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateRef("foo", (java.sql.Ref) null);
+ }
+
+ @Test
+ public void testUpdateRow() throws Exception {
+ try {
+ delegate.updateRow();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateRow();
+ }
+
+ @Test
+ public void testUpdateRowIdStringRowId() throws Exception {
+ try {
+ delegate.updateRowId("foo", (java.sql.RowId) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateRowId("foo", (java.sql.RowId) null);
+ }
+
+ @Test
+ public void testUpdateRowIdIntegerRowId() throws Exception {
+ try {
+ delegate.updateRowId(1, (java.sql.RowId) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateRowId(1, (java.sql.RowId) null);
+ }
+
+ @Test
+ public void testUpdateSQLXMLIntegerSQLXML() throws Exception {
+ try {
+ delegate.updateSQLXML(1, (java.sql.SQLXML) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateSQLXML(1, (java.sql.SQLXML) null);
+ }
+
+ @Test
+ public void testUpdateSQLXMLStringSQLXML() throws Exception {
+ try {
+ delegate.updateSQLXML("foo", (java.sql.SQLXML) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateSQLXML("foo", (java.sql.SQLXML) null);
+ }
+
+ @Test
+ public void testUpdateShortIntegerShort() throws Exception {
+ try {
+ delegate.updateShort(1, (short) 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateShort(1, (short) 1);
+ }
+
+ @Test
+ public void testUpdateShortStringShort() throws Exception {
+ try {
+ delegate.updateShort("foo", (short) 1);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateShort("foo", (short) 1);
+ }
+
+ @Test
+ public void testUpdateStringIntegerString() throws Exception {
+ try {
+ delegate.updateString(1, "foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateString(1, "foo");
+ }
+
+ @Test
+ public void testUpdateStringStringString() throws Exception {
+ try {
+ delegate.updateString("foo", "foo");
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateString("foo", "foo");
+ }
+
+ @Test
+ public void testUpdateTimeStringTime() throws Exception {
+ try {
+ delegate.updateTime("foo", (java.sql.Time) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateTime("foo", (java.sql.Time) null);
+ }
+
+ @Test
+ public void testUpdateTimeIntegerTime() throws Exception {
+ try {
+ delegate.updateTime(1, (java.sql.Time) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateTime(1, (java.sql.Time) null);
+ }
+
+ @Test
+ public void testUpdateTimestampIntegerTimestamp() throws Exception {
+ try {
+ delegate.updateTimestamp(1, (java.sql.Timestamp) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateTimestamp(1, (java.sql.Timestamp) null);
+ }
+
+ @Test
+ public void testUpdateTimestampStringTimestamp() throws Exception {
+ try {
+ delegate.updateTimestamp("foo", (java.sql.Timestamp) null);
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).updateTimestamp("foo", (java.sql.Timestamp) null);
+ }
+
+ @Test
+ public void testWasNull() throws Exception {
+ try {
+ delegate.wasNull();
+ } catch (SQLException e) {
+ }
+ verify(rs, times(1)).wasNull();
+ }
+
+ @Test
+ public void testToString() {
+ String toString = delegate.toString();
+ assertTrue(toString.contains("DelegatingResultSet"));
+ assertTrue(toString.contains("Mock for ResultSet"));
+ }
+
+ @Test
+ public void testWrap() throws SQLException {
+ DelegatingResultSet delegate = (DelegatingResultSet) DelegatingResultSet.wrapResultSet(conn, rs);
+ assertEquals(delegate, delegate.unwrap(ResultSet.class));
+ assertEquals(delegate, delegate.unwrap(DelegatingResultSet.class));
+ assertEquals(rs, delegate.unwrap(rs.getClass()));
+ assertNull(delegate.unwrap(String.class));
+ assertTrue(delegate.isWrapperFor(ResultSet.class));
+ assertTrue(delegate.isWrapperFor(DelegatingResultSet.class));
+ assertTrue(delegate.isWrapperFor(rs.getClass()));
+ assertFalse(delegate.isWrapperFor(String.class));
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestDelegatingStatement.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestDelegatingStatement.java b/src/test/java/org/apache/commons/dbcp2/TestDelegatingStatement.java
index cbed0d1..a12dd2e 100644
--- a/src/test/java/org/apache/commons/dbcp2/TestDelegatingStatement.java
+++ b/src/test/java/org/apache/commons/dbcp2/TestDelegatingStatement.java
@@ -22,6 +22,9 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
import java.lang.reflect.Proxy;
import java.sql.Connection;
@@ -31,39 +34,37 @@ import java.sql.Statement;
import org.junit.Before;
import org.junit.Test;
-/**
- */
public class TestDelegatingStatement {
private DelegatingConnection<Connection> conn = null;
private Connection delegateConn = null;
- private DelegatingStatement stmt = null;
- private Statement delegateStmt = null;
+ private Statement obj = null;
+ private DelegatingStatement delegate = null;
@Before
public void setUp() throws Exception {
delegateConn = new TesterConnection("test", "test");
- delegateStmt = new TesterStatement(delegateConn);
conn = new DelegatingConnection<>(delegateConn);
- stmt = new DelegatingStatement(conn,delegateStmt);
+ obj = mock(Statement.class);
+ delegate = new DelegatingStatement(conn, obj);
}
@Test
public void testExecuteQueryReturnsNull() throws Exception {
- assertNull(stmt.executeQuery("null"));
+ assertNull(delegate.executeQuery("null"));
}
@Test
public void testGetDelegate() throws Exception {
- assertEquals(delegateStmt,stmt.getDelegate());
+ assertEquals(obj,delegate.getDelegate());
}
@Test
public void testCheckOpen() throws Exception {
- stmt.checkOpen();
- stmt.close();
+ delegate.checkOpen();
+ delegate.close();
try {
- stmt.checkOpen();
+ delegate.checkOpen();
fail("Expecting SQLException");
} catch (final SQLException ex) {
// expected
@@ -99,4 +100,478 @@ public class TestDelegatingStatement {
return false;
}
}
+
+ @Test
+ public void testAddBatchString() throws Exception {
+ try {
+ delegate.addBatch("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).addBatch("foo");
+ }
+
+ @Test
+ public void testCancel() throws Exception {
+ try {
+ delegate.cancel();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).cancel();
+ }
+
+ @Test
+ public void testClearBatch() throws Exception {
+ try {
+ delegate.clearBatch();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).clearBatch();
+ }
+
+ @Test
+ public void testClearWarnings() throws Exception {
+ try {
+ delegate.clearWarnings();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).clearWarnings();
+ }
+
+ @Test
+ public void testClose() throws Exception {
+ try {
+ delegate.close();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).close();
+ }
+
+ @Test
+ public void testCloseOnCompletion() throws Exception {
+ try {
+ delegate.closeOnCompletion();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).closeOnCompletion();
+ }
+
+ @Test
+ public void testExecuteStringIntegerArray() throws Exception {
+ try {
+ delegate.execute("foo", (int[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).execute("foo", (int[]) null);
+ }
+
+ @Test
+ public void testExecuteString() throws Exception {
+ try {
+ delegate.execute("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).execute("foo");
+ }
+
+ @Test
+ public void testExecuteStringStringArray() throws Exception {
+ try {
+ delegate.execute("foo", (String[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).execute("foo", (String[]) null);
+ }
+
+ @Test
+ public void testExecuteStringInteger() throws Exception {
+ try {
+ delegate.execute("foo", 1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).execute("foo", 1);
+ }
+
+ @Test
+ public void testExecuteBatch() throws Exception {
+ try {
+ delegate.executeBatch();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeBatch();
+ }
+
+ @Test
+ public void testExecuteLargeBatch() throws Exception {
+ try {
+ delegate.executeLargeBatch();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeLargeBatch();
+ }
+
+ @Test
+ public void testExecuteLargeUpdateStringInteger() throws Exception {
+ try {
+ delegate.executeLargeUpdate("foo", 1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeLargeUpdate("foo", 1);
+ }
+
+ @Test
+ public void testExecuteLargeUpdateStringIntegerArray() throws Exception {
+ try {
+ delegate.executeLargeUpdate("foo", (int[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeLargeUpdate("foo", (int[]) null);
+ }
+
+ @Test
+ public void testExecuteLargeUpdateString() throws Exception {
+ try {
+ delegate.executeLargeUpdate("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeLargeUpdate("foo");
+ }
+
+ @Test
+ public void testExecuteLargeUpdateStringStringArray() throws Exception {
+ try {
+ delegate.executeLargeUpdate("foo", (String[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeLargeUpdate("foo", (String[]) null);
+ }
+
+ @Test
+ public void testExecuteQueryString() throws Exception {
+ try {
+ delegate.executeQuery("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeQuery("foo");
+ }
+
+ @Test
+ public void testExecuteUpdateStringIntegerArray() throws Exception {
+ try {
+ delegate.executeUpdate("foo", (int[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeUpdate("foo", (int[]) null);
+ }
+
+ @Test
+ public void testExecuteUpdateStringStringArray() throws Exception {
+ try {
+ delegate.executeUpdate("foo", (String[]) null);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeUpdate("foo", (String[]) null);
+ }
+
+ @Test
+ public void testExecuteUpdateString() throws Exception {
+ try {
+ delegate.executeUpdate("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeUpdate("foo");
+ }
+
+ @Test
+ public void testExecuteUpdateStringInteger() throws Exception {
+ try {
+ delegate.executeUpdate("foo", 1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).executeUpdate("foo", 1);
+ }
+
+ /**
+ * This method is a bit special, and return the delegate connection, not the
+ * wrapped statement's connection.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testGetConnection() throws Exception {
+ try {
+ delegate.getConnection();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(0)).getConnection();
+ }
+
+ @Test
+ public void testGetFetchDirection() throws Exception {
+ try {
+ delegate.getFetchDirection();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getFetchDirection();
+ }
+
+ @Test
+ public void testGetFetchSize() throws Exception {
+ try {
+ delegate.getFetchSize();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getFetchSize();
+ }
+
+ @Test
+ public void testGetGeneratedKeys() throws Exception {
+ try {
+ delegate.getGeneratedKeys();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getGeneratedKeys();
+ }
+
+ @Test
+ public void testGetLargeMaxRows() throws Exception {
+ try {
+ delegate.getLargeMaxRows();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getLargeMaxRows();
+ }
+
+ @Test
+ public void testGetLargeUpdateCount() throws Exception {
+ try {
+ delegate.getLargeUpdateCount();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getLargeUpdateCount();
+ }
+
+ @Test
+ public void testGetMaxFieldSize() throws Exception {
+ try {
+ delegate.getMaxFieldSize();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getMaxFieldSize();
+ }
+
+ @Test
+ public void testGetMaxRows() throws Exception {
+ try {
+ delegate.getMaxRows();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getMaxRows();
+ }
+
+ @Test
+ public void testGetMoreResultsInteger() throws Exception {
+ try {
+ delegate.getMoreResults(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getMoreResults(1);
+ }
+
+ @Test
+ public void testGetMoreResults() throws Exception {
+ try {
+ delegate.getMoreResults();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getMoreResults();
+ }
+
+ @Test
+ public void testGetQueryTimeout() throws Exception {
+ try {
+ delegate.getQueryTimeout();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getQueryTimeout();
+ }
+
+ @Test
+ public void testGetResultSet() throws Exception {
+ try {
+ delegate.getResultSet();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getResultSet();
+ }
+
+ @Test
+ public void testGetResultSetConcurrency() throws Exception {
+ try {
+ delegate.getResultSetConcurrency();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getResultSetConcurrency();
+ }
+
+ @Test
+ public void testGetResultSetHoldability() throws Exception {
+ try {
+ delegate.getResultSetHoldability();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getResultSetHoldability();
+ }
+
+ @Test
+ public void testGetResultSetType() throws Exception {
+ try {
+ delegate.getResultSetType();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getResultSetType();
+ }
+
+ @Test
+ public void testGetUpdateCount() throws Exception {
+ try {
+ delegate.getUpdateCount();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getUpdateCount();
+ }
+
+ @Test
+ public void testGetWarnings() throws Exception {
+ try {
+ delegate.getWarnings();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).getWarnings();
+ }
+
+ @Test
+ public void testIsCloseOnCompletion() throws Exception {
+ try {
+ delegate.isCloseOnCompletion();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).isCloseOnCompletion();
+ }
+
+ /**
+ * This method is a bit special, and call isClosed in the delegate object
+ * itself, not in the wrapped statement.
+ *
+ * @throws Exception
+ */
+ @Test
+ public void testIsClosed() throws Exception {
+ try {
+ delegate.isClosed();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(0)).isClosed();
+ }
+
+ @Test
+ public void testIsPoolable() throws Exception {
+ try {
+ delegate.isPoolable();
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).isPoolable();
+ }
+
+ @Test
+ public void testSetCursorNameString() throws Exception {
+ try {
+ delegate.setCursorName("foo");
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setCursorName("foo");
+ }
+
+ @Test
+ public void testSetEscapeProcessingBoolean() throws Exception {
+ try {
+ delegate.setEscapeProcessing(Boolean.TRUE);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setEscapeProcessing(Boolean.TRUE);
+ }
+
+ @Test
+ public void testSetFetchDirectionInteger() throws Exception {
+ try {
+ delegate.setFetchDirection(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setFetchDirection(1);
+ }
+
+ @Test
+ public void testSetFetchSizeInteger() throws Exception {
+ try {
+ delegate.setFetchSize(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setFetchSize(1);
+ }
+
+ @Test
+ public void testSetLargeMaxRowsLong() throws Exception {
+ try {
+ delegate.setLargeMaxRows(1l);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setLargeMaxRows(1l);
+ }
+
+ @Test
+ public void testSetMaxFieldSizeInteger() throws Exception {
+ try {
+ delegate.setMaxFieldSize(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setMaxFieldSize(1);
+ }
+
+ @Test
+ public void testSetMaxRowsInteger() throws Exception {
+ try {
+ delegate.setMaxRows(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setMaxRows(1);
+ }
+
+ @Test
+ public void testSetPoolableBoolean() throws Exception {
+ try {
+ delegate.setPoolable(Boolean.TRUE);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setPoolable(Boolean.TRUE);
+ }
+
+ @Test
+ public void testSetQueryTimeoutInteger() throws Exception {
+ try {
+ delegate.setQueryTimeout(1);
+ } catch (SQLException e) {
+ }
+ verify(obj, times(1)).setQueryTimeout(1);
+ }
+
+ @Test
+ public void testWrap() throws SQLException {
+ assertEquals(delegate, delegate.unwrap(Statement.class));
+ assertEquals(delegate, delegate.unwrap(DelegatingStatement.class));
+ assertEquals(obj, delegate.unwrap(obj.getClass()));
+ assertNull(delegate.unwrap(String.class));
+ assertTrue(delegate.isWrapperFor(Statement.class));
+ assertTrue(delegate.isWrapperFor(DelegatingStatement.class));
+ assertTrue(delegate.isWrapperFor(obj.getClass()));
+ assertFalse(delegate.isWrapperFor(String.class));
+ }
}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestDriverConnectionFactory.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestDriverConnectionFactory.java b/src/test/java/org/apache/commons/dbcp2/TestDriverConnectionFactory.java
new file mode 100644
index 0000000..78a5988
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbcp2/TestDriverConnectionFactory.java
@@ -0,0 +1,48 @@
+/*
+ * 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.dbcp2;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+import org.junit.Test;
+
+/**
+ * Tests for DriverConnectionFactory.
+ */
+public class TestDriverConnectionFactory {
+
+ @Test
+ public void testDriverConnectionFactoryToString() {
+ DriverConnectionFactory cf = new DriverConnectionFactory(
+ new TesterDriver(), "jdbc:apache:commons:testdriver", null);
+ String toString = cf.toString();
+ assertTrue(toString.contains("jdbc:apache:commons:testdriver"));
+ }
+
+ @Test
+ public void testCreateConnection() throws SQLException {
+ DriverConnectionFactory cf = new DriverConnectionFactory(
+ new TesterDriver(), "jdbc:apache:commons:testdriver", null);
+ Connection conn = cf.createConnection();
+ assertEquals(0, conn.getMetaData().getDriverMajorVersion());
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java b/src/test/java/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java
index 98c3f73..31de811 100644
--- a/src/test/java/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java
+++ b/src/test/java/org/apache/commons/dbcp2/TestDriverManagerConnectionFactory.java
@@ -20,6 +20,7 @@ package org.apache.commons.dbcp2;
import static org.junit.Assert.fail;
import java.sql.Connection;
+import java.sql.SQLException;
import java.util.Properties;
import javax.sql.DataSource;
@@ -66,6 +67,30 @@ public class TestDriverManagerConnectionFactory {
testDriverManagerInit(false);
}
+ @Test(expected=IndexOutOfBoundsException.class) // thrown by TestDriver due to missing user
+ public void testDriverManagerWithoutUser() throws SQLException {
+ DriverManagerConnectionFactory cf = new DriverManagerConnectionFactory("jdbc:apache:commons:testdriver", null, "pass");
+ cf.createConnection();
+ }
+
+ @Test(expected=SQLException.class) // thrown by TestDriver due to invalid password
+ public void testDriverManagerWithoutPassword() throws SQLException {
+ DriverManagerConnectionFactory cf = new DriverManagerConnectionFactory("jdbc:apache:commons:testdriver", "user", null);
+ cf.createConnection();
+ }
+
+ @Test(expected=ArrayIndexOutOfBoundsException.class) // thrown by TestDriver due to missing user
+ public void testDriverManagerWithoutCredentials() throws SQLException {
+ DriverManagerConnectionFactory cf = new DriverManagerConnectionFactory("jdbc:apache:commons:testdriver", null, null);
+ cf.createConnection();
+ }
+
+ @Test
+ public void testDriverManagerCredentialsInUrl() throws SQLException {
+ DriverManagerConnectionFactory cf = new DriverManagerConnectionFactory("jdbc:apache:commons:testdriver;user=foo;password=bar", null, null);
+ cf.createConnection();
+ }
+
public void testDriverManagerInit(final boolean withProperties) throws Exception {
final GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(10);
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestLifetimeExceededException.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestLifetimeExceededException.java b/src/test/java/org/apache/commons/dbcp2/TestLifetimeExceededException.java
new file mode 100644
index 0000000..69ae9df
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbcp2/TestLifetimeExceededException.java
@@ -0,0 +1,41 @@
+/*
+ * 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.dbcp2;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import org.junit.Test;
+
+/**
+ * Tests for LifetimeExceededException.
+ */
+public class TestLifetimeExceededException {
+
+ @Test
+ public void testLifetimeExceededExceptionNoMessage() {
+ LifetimeExceededException exception = new LifetimeExceededException();
+ assertNull(exception.getMessage());
+ }
+
+ @Test
+ public void testLifetimeExceededException() {
+ LifetimeExceededException exception = new LifetimeExceededException("car");
+ assertEquals("car", exception.getMessage());
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestListException.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestListException.java b/src/test/java/org/apache/commons/dbcp2/TestListException.java
new file mode 100644
index 0000000..de24e8f
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbcp2/TestListException.java
@@ -0,0 +1,50 @@
+/*
+ * 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.dbcp2;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+
+import java.util.List;
+
+import org.junit.Test;
+
+import edu.emory.mathcs.backport.java.util.Arrays;
+
+/**
+ * Tests for ListException.
+ */
+public class TestListException {
+
+ @Test
+ public void testNulls() {
+ ListException list = new ListException(null, null);
+ assertNull(list.getMessage());
+ assertNull(list.getExceptionList());
+ }
+
+ @Test
+ public void testExceptionList() {
+ @SuppressWarnings("unchecked")
+ List<Throwable> exceptions = Arrays.asList(new Throwable[] {new NullPointerException(), new RuntimeException()});
+ ListException list = new ListException("Internal Error", exceptions);
+ assertEquals("Internal Error", list.getMessage());
+ assertArrayEquals(exceptions.toArray(), list.getExceptionList().toArray());
+ }
+}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/TestPStmtKey.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/TestPStmtKey.java b/src/test/java/org/apache/commons/dbcp2/TestPStmtKey.java
index 2cdd932..a1002e8 100644
--- a/src/test/java/org/apache/commons/dbcp2/TestPStmtKey.java
+++ b/src/test/java/org/apache/commons/dbcp2/TestPStmtKey.java
@@ -16,8 +16,16 @@
*/
package org.apache.commons.dbcp2;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
+import java.sql.Statement;
import java.util.Arrays;
+import javax.resource.cci.ResultSet;
+
import org.apache.commons.dbcp2.PoolingConnection.StatementType;
import org.junit.Assert;
import org.junit.Test;
@@ -196,4 +204,61 @@ public class TestPStmtKey {
input[1] = "D";
Assert.assertFalse(Arrays.equals(input, pStmtKey.getColumnNames()));
}
+
+ @Test
+ public void testGettersSetters() {
+ final PStmtKey pStmtKey = new PStmtKey("SELECT 1", "catalog", "public");
+ assertEquals("SELECT 1", pStmtKey.getSql());
+ assertEquals("public", pStmtKey.getSchema());
+ assertEquals("catalog", pStmtKey.getCatalog());
+ assertNull(pStmtKey.getAutoGeneratedKeys());
+ assertNull(pStmtKey.getResultSetConcurrency());
+ assertNull(pStmtKey.getResultSetHoldability());
+ assertNull(pStmtKey.getResultSetType());
+ assertEquals(StatementType.PREPARED_STATEMENT, pStmtKey.getStmtType());
+ }
+
+ @Test
+ public void testEquals() {
+ final PStmtKey pStmtKey = new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT);
+ assertTrue(pStmtKey.equals(pStmtKey));
+ assertFalse(pStmtKey.equals(null));
+ assertFalse(pStmtKey.equals(new Object()));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 2", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT)));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 1", "anothercatalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT)));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 1", "catalog", "private",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT)));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT)));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_UPDATABLE,
+ StatementType.CALLABLE_STATEMENT)));
+ assertFalse(pStmtKey.equals(new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.PREPARED_STATEMENT)));
+ assertTrue(pStmtKey.equals(new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT)));
+ assertEquals(pStmtKey.hashCode(), new PStmtKey("SELECT 1", "catalog", "public",
+ ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY,
+ StatementType.CALLABLE_STATEMENT).hashCode());
+ }
+
+ @Test
+ public void testToString() {
+ final PStmtKey pStmtKey = new PStmtKey("SELECT 1", "catalog", "public",
+ StatementType.CALLABLE_STATEMENT, Statement.RETURN_GENERATED_KEYS);
+ assertTrue(pStmtKey.toString().contains("sql=SELECT 1"));
+ assertTrue(pStmtKey.toString().contains("schema=public"));
+ assertTrue(pStmtKey.toString().contains("autoGeneratedKeys=1"));
+ assertTrue(pStmtKey.toString().contains("statementType=CALLABLE_STATEMENT"));
+ }
}
http://git-wip-us.apache.org/repos/asf/commons-dbcp/blob/64a13ee3/src/test/java/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java b/src/test/java/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java
index 8099dc2..a3e0f4e 100644
--- a/src/test/java/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java
+++ b/src/test/java/org/apache/commons/dbcp2/cpdsadapter/TestDriverAdapterCPDS.java
@@ -17,17 +17,24 @@
package org.apache.commons.dbcp2.cpdsadapter;
+import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Properties;
+import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
+import java.sql.SQLFeatureNotSupportedException;
+import javax.naming.NamingException;
+import javax.naming.Reference;
+import javax.naming.StringRefAddr;
import javax.sql.DataSource;
import org.apache.commons.dbcp2.datasources.SharedPoolDataSource;
@@ -148,6 +155,7 @@ public class TestDriverAdapterCPDS {
// This will overwrite field value
final Properties properties = new Properties();
properties.put("user", "foo");
+ properties.put("password", pcds.getPassword());
pcds.setConnectionProperties(properties);
pcds.getPooledConnection().close();
assertEquals("foo", pcds.getUser());
@@ -161,6 +169,14 @@ public class TestDriverAdapterCPDS {
assertEquals("bar", pcds.getConnectionProperties().getProperty("password"));
}
+ @Test(expected=IllegalStateException.class)
+ public void testSetConnectionPropertiesConnectionCalled() throws Exception {
+ final Properties properties = new Properties();
+ // call to the connection
+ pcds.getPooledConnection().close();
+ pcds.setConnectionProperties(properties);
+ }
+
@Test
public void testSetConnectionPropertiesNull() throws Exception {
pcds.setConnectionProperties(null);
@@ -275,4 +291,68 @@ public class TestDriverAdapterCPDS {
return failed;
}
}
+
+ @Test(expected=SQLFeatureNotSupportedException.class)
+ public void testGetParentLogger() throws SQLFeatureNotSupportedException {
+ pcds.getParentLogger();
+ }
+
+ @Test
+ public void testGetReference() throws NamingException {
+ Reference ref = pcds.getReference();
+ assertEquals(pcds.getDriver(), ref.get("driver").getContent());
+ assertEquals(pcds.getDescription(), ref.get("description").getContent());
+ }
+
+ @Test
+ public void testGettersAndSetters() {
+ pcds.setUser("foo");
+ assertEquals("foo", pcds.getUser());
+ pcds.setPassword("bar");
+ assertEquals("bar", pcds.getPassword());
+ pcds.setPassword(new char[] {'a', 'b'});
+ assertArrayEquals(new char[] {'a', 'b'}, pcds.getPasswordCharArray());
+ PrintWriter pw = new PrintWriter(System.err);
+ pcds.setLogWriter(pw);
+ assertEquals(pw, pcds.getLogWriter());
+ pcds.setLoginTimeout(10);
+ assertEquals(10, pcds.getLoginTimeout());
+ pcds.setMaxIdle(100);
+ assertEquals(100, pcds.getMaxIdle());
+ pcds.setTimeBetweenEvictionRunsMillis(100);
+ assertEquals(100, pcds.getTimeBetweenEvictionRunsMillis());
+ pcds.setNumTestsPerEvictionRun(1);
+ assertEquals(1, pcds.getNumTestsPerEvictionRun());
+ pcds.setMinEvictableIdleTimeMillis(11);
+ assertEquals(11, pcds.getMinEvictableIdleTimeMillis());
+ pcds.setDescription("jo");
+ assertEquals("jo", pcds.getDescription());
+ }
+
+ @Test
+ public void testGetObjectInstanceNull() throws Exception {
+ Object o = pcds.getObjectInstance(null, null, null, null);
+ assertNull(o);
+ }
+
+ @Test
+ public void testGetObjectInstance() throws Exception {
+ Reference ref = pcds.getReference();
+ Object o = pcds.getObjectInstance(ref, null, null, null);
+ assertEquals(pcds.getDriver(), ((DriverAdapterCPDS) o).getDriver());
+ }
+
+ @Test
+ public void testGetObjectInstanceChangeDescription() throws Exception {
+ Reference ref = pcds.getReference();
+ for (int i = 0; i < ref.size(); i++) {
+ if (ref.get(i).getType().equals("description")) {
+ ref.remove(i);
+ break;
+ }
+ }
+ ref.add(new StringRefAddr("description", "anything"));
+ Object o = pcds.getObjectInstance(ref, null, null, null);
+ assertEquals(pcds.getDescription(), ((DriverAdapterCPDS) o).getDescription());
+ }
}