commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From thecarlh...@apache.org
Subject [01/58] [abbrv] commons-dbutils git commit: Changed the package names so dbutils and dbutils2 won't conflict if both loaded
Date Fri, 07 Jul 2017 02:06:23 GMT
Repository: commons-dbutils
Updated Branches:
  refs/heads/2_0 [created] 8de35c7e2


http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/41d6d58c/src/test/java/org/apache/commons/dbutils2/wrappers/SqlNullCheckedResultSetTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils2/wrappers/SqlNullCheckedResultSetTest.java
b/src/test/java/org/apache/commons/dbutils2/wrappers/SqlNullCheckedResultSetTest.java
new file mode 100644
index 0000000..406d298
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbutils2/wrappers/SqlNullCheckedResultSetTest.java
@@ -0,0 +1,1021 @@
+/*
+ * 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.dbutils2.wrappers;
+
+import java.io.ByteArrayInputStream;
+import java.io.CharArrayReader;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.math.BigDecimal;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.Map;
+
+import org.apache.commons.dbutils2.BaseTestCase;
+import org.apache.commons.dbutils2.ProxyFactory;
+import org.apache.commons.dbutils2.wrappers.SqlNullCheckedResultSet;
+
+/**
+ * Test cases for <code>SqlNullCheckedResultSet</code> class.
+ */
+public class SqlNullCheckedResultSetTest extends BaseTestCase {
+
+    private SqlNullCheckedResultSet rs2 = null;
+
+    /**
+     * Sets up instance variables required by this test case.
+     */
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+
+        rs2 =
+                new SqlNullCheckedResultSet(
+                        ProxyFactory.instance().createResultSet(
+                                new SqlNullUncheckedMockResultSet()));
+
+        rs = ProxyFactory.instance().createResultSet(rs2); // Override superclass field
+    }
+
+    /**
+     * Tests the getAsciiStream implementation.
+     */
+    public void testGetAsciiStream() throws SQLException {
+
+        assertNull(rs.getAsciiStream(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getAsciiStream("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        InputStream stream = new ByteArrayInputStream(new byte[0]);
+        rs2.setNullAsciiStream(stream);
+        assertNotNull(rs.getAsciiStream(1));
+        assertEquals(stream, rs.getAsciiStream(1));
+        assertNotNull(rs.getAsciiStream("column"));
+        assertEquals(stream, rs.getAsciiStream("column"));
+
+    }
+
+    /**
+     * Tests the getBigDecimal implementation.
+     */
+    public void testGetBigDecimal() throws SQLException {
+
+        assertNull(rs.getBigDecimal(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getBigDecimal("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        BigDecimal bd = new BigDecimal(5.0);
+        rs2.setNullBigDecimal(bd);
+        assertNotNull(rs.getBigDecimal(1));
+        assertEquals(bd, rs.getBigDecimal(1));
+        assertNotNull(rs.getBigDecimal("column"));
+        assertEquals(bd, rs.getBigDecimal("column"));
+
+    }
+
+    /**
+     * Tests the getBinaryStream implementation.
+     */
+    public void testGetBinaryStream() throws SQLException {
+
+        assertNull(rs.getBinaryStream(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getBinaryStream("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        InputStream stream = new ByteArrayInputStream(new byte[0]);
+        rs2.setNullBinaryStream(stream);
+        assertNotNull(rs.getBinaryStream(1));
+        assertEquals(stream, rs.getBinaryStream(1));
+        assertNotNull(rs.getBinaryStream("column"));
+        assertEquals(stream, rs.getBinaryStream("column"));
+
+    }
+
+    /**
+     * Tests the getBlob implementation.
+     */
+    public void testGetBlob() throws SQLException {
+
+        assertNull(rs.getBlob(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getBlob("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Blob blob = new SqlNullCheckedResultSetMockBlob();
+        rs2.setNullBlob(blob);
+        assertNotNull(rs.getBlob(1));
+        assertEquals(blob, rs.getBlob(1));
+        assertNotNull(rs.getBlob("column"));
+        assertEquals(blob, rs.getBlob("column"));
+
+    }
+
+    /**
+     * Tests the getBoolean implementation.
+     */
+    public void testGetBoolean() throws SQLException {
+
+        assertEquals(false, rs.getBoolean(1));
+        assertTrue(rs.wasNull());
+        assertEquals(false, rs.getBoolean("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        rs2.setNullBoolean(true);
+        assertEquals(true, rs.getBoolean(1));
+        assertEquals(true, rs.getBoolean("column"));
+
+    }
+
+    /**
+     * Tests the getByte implementation.
+     */
+    public void testGetByte() throws SQLException {
+
+        assertEquals((byte) 0, rs.getByte(1));
+        assertTrue(rs.wasNull());
+        assertEquals((byte) 0, rs.getByte("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        byte b = (byte) 10;
+        rs2.setNullByte(b);
+        assertEquals(b, rs.getByte(1));
+        assertEquals(b, rs.getByte("column"));
+
+    }
+
+    /**
+     * Tests the getByte implementation.
+     */
+    public void testGetBytes() throws SQLException {
+
+        assertNull(rs.getBytes(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getBytes("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        byte[] b = new byte[5];
+        for (int i = 0; i < 5; i++) {
+            b[0] = (byte) i;
+        }
+        rs2.setNullBytes(b);
+        assertNotNull(rs.getBytes(1));
+        assertArrayEquals(b, rs.getBytes(1));
+        assertNotNull(rs.getBytes("column"));
+        assertArrayEquals(b, rs.getBytes("column"));
+
+    }
+
+    private static void assertArrayEquals(byte[] expected, byte[] actual) {
+        if (expected == actual) return;
+        if (expected.length != actual.length) {
+            failNotEquals(null, Arrays.toString(expected), Arrays.toString(actual));
+        }
+        for (int i = 0; i < expected.length; i++) {
+            byte expectedItem = expected[i];
+            byte actualItem = actual[i];
+            assertEquals("Array not equal at index " + i, expectedItem, actualItem);
+        }
+    }
+
+    /**
+     * Tests the getCharacterStream implementation.
+     */
+    public void testGetCharacterStream() throws SQLException {
+
+        assertNull(rs.getCharacterStream(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getCharacterStream("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Reader reader = new CharArrayReader("this is a string".toCharArray());
+        rs2.setNullCharacterStream(reader);
+        assertNotNull(rs.getCharacterStream(1));
+        assertEquals(reader, rs.getCharacterStream(1));
+        assertNotNull(rs.getCharacterStream("column"));
+        assertEquals(reader, rs.getCharacterStream("column"));
+
+    }
+
+    /**
+     * Tests the getClob implementation.
+     */
+    public void testGetClob() throws SQLException {
+
+        assertNull(rs.getClob(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getClob("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Clob clob = new SqlNullCheckedResultSetMockClob();
+        rs2.setNullClob(clob);
+        assertNotNull(rs.getClob(1));
+        assertEquals(clob, rs.getClob(1));
+        assertNotNull(rs.getClob("column"));
+        assertEquals(clob, rs.getClob("column"));
+
+    }
+
+    /**
+     * Tests the getDate implementation.
+     */
+    public void testGetDate() throws SQLException {
+
+        assertNull(rs.getDate(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getDate("column"));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getDate(1, Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getDate("column", Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        java.sql.Date date = new java.sql.Date(new java.util.Date().getTime());
+        rs2.setNullDate(date);
+        assertNotNull(rs.getDate(1));
+        assertEquals(date, rs.getDate(1));
+        assertNotNull(rs.getDate("column"));
+        assertEquals(date, rs.getDate("column"));
+        assertNotNull(rs.getDate(1, Calendar.getInstance()));
+        assertEquals(date, rs.getDate(1, Calendar.getInstance()));
+        assertNotNull(rs.getDate("column", Calendar.getInstance()));
+        assertEquals(date, rs.getDate("column", Calendar.getInstance()));
+
+    }
+
+    /**
+     * Tests the getDouble implementation.
+     */
+    public void testGetDouble() throws SQLException {
+
+        assertEquals(0.0, rs.getDouble(1), 0.0);
+        assertTrue(rs.wasNull());
+        assertEquals(0.0, rs.getDouble("column"), 0.0);
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        double d = 10.0;
+        rs2.setNullDouble(d);
+        assertEquals(d, rs.getDouble(1), 0.0);
+        assertEquals(d, rs.getDouble("column"), 0.0);
+
+    }
+
+    /**
+     * Tests the getFloat implementation.
+     */
+    public void testGetFloat() throws SQLException {
+        assertEquals(0, rs.getFloat(1), 0.0);
+        assertTrue(rs.wasNull());
+        assertEquals(0, rs.getFloat("column"), 0.0);
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        float f = 10;
+        rs2.setNullFloat(f);
+        assertEquals(f, rs.getFloat(1), 0.0);
+        assertEquals(f, rs.getFloat("column"), 0.0);
+    }
+
+    /**
+     * Tests the getInt implementation.
+     */
+    public void testGetInt() throws SQLException {
+        assertEquals(0, rs.getInt(1));
+        assertTrue(rs.wasNull());
+        assertEquals(0, rs.getInt("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        int i = 10;
+        rs2.setNullInt(i);
+        assertEquals(i, rs.getInt(1));
+        assertEquals(i, rs.getInt("column"));
+    }
+
+    /**
+     * Tests the getLong implementation.
+     */
+    public void testGetLong() throws SQLException {
+        assertEquals(0, rs.getLong(1));
+        assertTrue(rs.wasNull());
+        assertEquals(0, rs.getLong("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        long l = 10;
+        rs2.setNullLong(l);
+        assertEquals(l, rs.getLong(1));
+        assertEquals(l, rs.getLong("column"));
+    }
+
+    /**
+     * Tests the getObject implementation.
+     */
+    public void testGetObject() throws SQLException {
+
+        assertNull(rs.getObject(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getObject("column"));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getObject(1, (Map<String, Class<?>>) null));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getObject("column", (Map<String, Class<?>>) null));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Object o = new Object();
+        rs2.setNullObject(o);
+        assertNotNull(rs.getObject(1));
+        assertEquals(o, rs.getObject(1));
+        assertNotNull(rs.getObject("column"));
+        assertEquals(o, rs.getObject("column"));
+        assertNotNull(rs.getObject(1, (Map<String, Class<?>>) null));
+        assertEquals(o, rs.getObject(1, (Map<String, Class<?>>) null));
+        assertNotNull(rs.getObject("column", (Map<String, Class<?>>) null));
+        assertEquals(o, rs.getObject("column", (Map<String, Class<?>>) null));
+
+    }
+
+    /**
+     * Tests the getRef implementation.
+     */
+    public void testGetRef() throws SQLException {
+
+        assertNull(rs.getRef(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getRef("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Ref ref = new SqlNullCheckedResultSetMockRef();
+        rs2.setNullRef(ref);
+        assertNotNull(rs.getRef(1));
+        assertEquals(ref, rs.getRef(1));
+        assertNotNull(rs.getRef("column"));
+        assertEquals(ref, rs.getRef("column"));
+
+    }
+
+    /**
+     * Tests the getShort implementation.
+     */
+    public void testGetShort() throws SQLException {
+
+        assertEquals((short) 0, rs.getShort(1));
+        assertTrue(rs.wasNull());
+        assertEquals((short) 0, rs.getShort("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        short s = (short) 10;
+        rs2.setNullShort(s);
+        assertEquals(s, rs.getShort(1));
+        assertEquals(s, rs.getShort("column"));
+    }
+
+    /**
+     * Tests the getString implementation.
+     */
+    public void testGetString() throws SQLException {
+        assertEquals(null, rs.getString(1));
+        assertTrue(rs.wasNull());
+        assertEquals(null, rs.getString("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        String s = "hello, world";
+        rs2.setNullString(s);
+        assertEquals(s, rs.getString(1));
+        assertEquals(s, rs.getString("column"));
+    }
+
+    /**
+     * Tests the getTime implementation.
+     */
+    public void testGetTime() throws SQLException {
+
+        assertNull(rs.getTime(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTime("column"));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTime(1, Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTime("column", Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Time time = new Time(new java.util.Date().getTime());
+        rs2.setNullTime(time);
+        assertNotNull(rs.getTime(1));
+        assertEquals(time, rs.getTime(1));
+        assertNotNull(rs.getTime("column"));
+        assertEquals(time, rs.getTime("column"));
+        assertNotNull(rs.getTime(1, Calendar.getInstance()));
+        assertEquals(time, rs.getTime(1, Calendar.getInstance()));
+        assertNotNull(rs.getTime("column", Calendar.getInstance()));
+        assertEquals(time, rs.getTime("column", Calendar.getInstance()));
+
+    }
+
+    /**
+     * Tests the getTimestamp implementation.
+     */
+    public void testGetTimestamp() throws SQLException {
+
+        assertNull(rs.getTimestamp(1));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTimestamp("column"));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTimestamp(1, Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        assertNull(rs.getTimestamp("column", Calendar.getInstance()));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        Timestamp ts = new Timestamp(new java.util.Date().getTime());
+        rs2.setNullTimestamp(ts);
+        assertNotNull(rs.getTimestamp(1));
+        assertEquals(ts, rs.getTimestamp(1));
+        assertNotNull(rs.getTimestamp("column"));
+        assertEquals(ts, rs.getTimestamp("column"));
+        assertNotNull(rs.getTimestamp(1, Calendar.getInstance()));
+        assertEquals(ts, rs.getTimestamp(1, Calendar.getInstance()));
+        assertNotNull(rs.getTimestamp("column", Calendar.getInstance()));
+        assertEquals(ts, rs.getTimestamp("column", Calendar.getInstance()));
+    }
+
+    /**
+     * Tests the getURL and setNullURL implementations.
+     *
+     * Uses reflection to allow for building under JDK 1.3.
+     */
+    public void testURL() throws SQLException, MalformedURLException,
+    IllegalAccessException, IllegalArgumentException,
+    java.lang.reflect.InvocationTargetException
+    {
+        Method getUrlInt = null;
+        Method getUrlString = null;
+        try {
+            getUrlInt = ResultSet.class.getMethod("getURL",
+                    new Class[] { Integer.TYPE } );
+            getUrlString = ResultSet.class.getMethod("getURL",
+                    new Class[] { String.class } );
+        } catch(NoSuchMethodException e) {
+            // ignore
+        } catch(SecurityException e) {
+            // ignore
+        }
+        if (getUrlInt != null && getUrlString != null) {
+            assertEquals(null, getUrlInt.invoke(rs,
+                    new Object[] { Integer.valueOf(1) } ) );
+            assertTrue(rs.wasNull());
+            assertEquals(null, getUrlString.invoke(rs,
+                    new Object[] { "column" } ) );
+            assertTrue(rs.wasNull());
+            // Set what gets returned to something other than the default
+            URL u = new URL("http://www.apache.org");
+            rs2.setNullURL(u);
+            assertEquals(u, getUrlInt.invoke(rs,
+                    new Object[] { Integer.valueOf(1) } ) );
+            assertEquals(u, getUrlString.invoke(rs,
+                    new Object[] { "column" } ) );
+        }
+    }
+
+    /**
+     * Tests the setNullAsciiStream implementation.
+     */
+    public void testSetNullAsciiStream() throws SQLException {
+
+        assertNull(rs2.getNullAsciiStream());
+        // Set what gets returned to something other than the default
+        InputStream stream = new ByteArrayInputStream(new byte[0]);
+        rs2.setNullAsciiStream(stream);
+        assertNotNull(rs.getAsciiStream(1));
+        assertEquals(stream, rs.getAsciiStream(1));
+        assertNotNull(rs.getAsciiStream("column"));
+        assertEquals(stream, rs.getAsciiStream("column"));
+
+    }
+
+    /**
+     * Tests the setNullBigDecimal implementation.
+     */
+    public void testSetNullBigDecimal() throws SQLException {
+
+        assertNull(rs2.getNullBigDecimal());
+        // Set what gets returned to something other than the default
+        BigDecimal bd = new BigDecimal(5.0);
+        rs2.setNullBigDecimal(bd);
+        assertNotNull(rs.getBigDecimal(1));
+        assertEquals(bd, rs.getBigDecimal(1));
+        assertNotNull(rs.getBigDecimal("column"));
+        assertEquals(bd, rs.getBigDecimal("column"));
+
+    }
+
+    /**
+     * Tests the setNullBinaryStream implementation.
+     */
+    public void testSetNullBinaryStream() throws SQLException {
+
+        assertNull(rs2.getNullBinaryStream());
+        // Set what gets returned to something other than the default
+        InputStream stream = new ByteArrayInputStream(new byte[0]);
+        rs2.setNullBinaryStream(stream);
+        assertNotNull(rs.getBinaryStream(1));
+        assertEquals(stream, rs.getBinaryStream(1));
+        assertNotNull(rs.getBinaryStream("column"));
+        assertEquals(stream, rs.getBinaryStream("column"));
+
+    }
+
+    /**
+     * Tests the setNullBlob implementation.
+     */
+    public void testSetNullBlob() throws SQLException {
+
+        assertNull(rs2.getNullBlob());
+        // Set what gets returned to something other than the default
+        Blob blob = new SqlNullCheckedResultSetMockBlob();
+        rs2.setNullBlob(blob);
+        assertNotNull(rs.getBlob(1));
+        assertEquals(blob, rs.getBlob(1));
+        assertNotNull(rs.getBlob("column"));
+        assertEquals(blob, rs.getBlob("column"));
+
+    }
+
+    /**
+     * Tests the setNullBoolean implementation.
+     */
+    public void testSetNullBoolean() throws SQLException {
+
+        assertEquals(false, rs2.getNullBoolean());
+        // Set what gets returned to something other than the default
+        rs2.setNullBoolean(true);
+        assertEquals(true, rs.getBoolean(1));
+        assertEquals(true, rs.getBoolean("column"));
+
+    }
+
+    /**
+     * Tests the setNullByte implementation.
+     */
+    public void testSetNullByte() throws SQLException {
+
+        assertEquals((byte) 0, rs2.getNullByte());
+        // Set what gets returned to something other than the default
+        byte b = (byte) 10;
+        rs2.setNullByte(b);
+        assertEquals(b, rs.getByte(1));
+        assertEquals(b, rs.getByte("column"));
+
+    }
+
+    /**
+     * Tests the setNullByte implementation.
+     */
+    public void testSetNullBytes() throws SQLException {
+
+        assertNull(rs2.getNullBytes());
+        // Set what gets returned to something other than the default
+        byte[] b = new byte[5];
+        for (int i = 0; i < 5; i++) {
+            b[0] = (byte) i;
+        }
+        rs2.setNullBytes(b);
+        assertNotNull(rs.getBytes(1));
+        assertArrayEquals(b, rs.getBytes(1));
+        assertNotNull(rs.getBytes("column"));
+        assertArrayEquals(b, rs.getBytes("column"));
+
+    }
+
+    /**
+     * Tests the setNullCharacterStream implementation.
+     */
+    public void testSetNullCharacterStream() throws SQLException {
+
+        assertNull(rs2.getNullCharacterStream());
+        // Set what gets returned to something other than the default
+        Reader reader = new CharArrayReader("this is a string".toCharArray());
+        rs2.setNullCharacterStream(reader);
+        assertNotNull(rs.getCharacterStream(1));
+        assertEquals(reader, rs.getCharacterStream(1));
+        assertNotNull(rs.getCharacterStream("column"));
+        assertEquals(reader, rs.getCharacterStream("column"));
+
+    }
+
+    /**
+     * Tests the setNullClob implementation.
+     */
+    public void testSetNullClob() throws SQLException {
+
+        assertNull(rs2.getNullClob());
+        // Set what gets returned to something other than the default
+        Clob clob = new SqlNullCheckedResultSetMockClob();
+        rs2.setNullClob(clob);
+        assertNotNull(rs.getClob(1));
+        assertEquals(clob, rs.getClob(1));
+        assertNotNull(rs.getClob("column"));
+        assertEquals(clob, rs.getClob("column"));
+
+    }
+
+    /**
+     * Tests the setNullDate implementation.
+     */
+    public void testSetNullDate() throws SQLException {
+
+        assertNull(rs2.getNullDate());
+        // Set what gets returned to something other than the default
+        java.sql.Date date = new java.sql.Date(new java.util.Date().getTime());
+        rs2.setNullDate(date);
+        assertNotNull(rs.getDate(1));
+        assertEquals(date, rs.getDate(1));
+        assertNotNull(rs.getDate("column"));
+        assertEquals(date, rs.getDate("column"));
+        assertNotNull(rs.getDate(1, Calendar.getInstance()));
+        assertEquals(date, rs.getDate(1, Calendar.getInstance()));
+        assertNotNull(rs.getDate("column", Calendar.getInstance()));
+        assertEquals(date, rs.getDate("column", Calendar.getInstance()));
+
+    }
+
+    /**
+     * Tests the setNullDouble implementation.
+     */
+    public void testSetNullDouble() throws SQLException {
+        assertEquals(0.0, rs2.getNullDouble(), 0.0);
+        // Set what gets returned to something other than the default
+        double d = 10.0;
+        rs2.setNullDouble(d);
+        assertEquals(d, rs.getDouble(1), 0.0);
+        assertEquals(d, rs.getDouble("column"), 0.0);
+    }
+
+    /**
+     * Tests the setNullFloat implementation.
+     */
+    public void testSetNullFloat() throws SQLException {
+        assertEquals((float) 0.0, rs2.getNullFloat(), 0.0);
+        // Set what gets returned to something other than the default
+        float f = (float) 10.0;
+        rs2.setNullFloat(f);
+        assertEquals(f, rs.getFloat(1), 0.0);
+        assertEquals(f, rs.getFloat("column"), 0.0);
+    }
+
+    /**
+     * Tests the setNullInt implementation.
+     */
+    public void testSetNullInt() throws SQLException {
+        assertEquals(0, rs2.getNullInt());
+        assertEquals(0, rs.getInt(1));
+        assertTrue(rs.wasNull());
+        assertEquals(0, rs.getInt("column"));
+        assertTrue(rs.wasNull());
+        // Set what gets returned to something other than the default
+        int i = 10;
+        rs2.setNullInt(i);
+        assertEquals(i, rs.getInt(1));
+        assertEquals(i, rs.getInt("column"));
+    }
+
+    /**
+     * Tests the setNullLong implementation.
+     */
+    public void testSetNullLong() throws SQLException {
+        assertEquals(0, rs2.getNullLong());
+        // Set what gets returned to something other than the default
+        long l = 10;
+        rs2.setNullLong(l);
+        assertEquals(l, rs.getLong(1));
+        assertEquals(l, rs.getLong("column"));
+    }
+
+    /**
+     * Tests the setNullObject implementation.
+     */
+    public void testSetNullObject() throws SQLException {
+        assertNull(rs2.getNullObject());
+        // Set what gets returned to something other than the default
+        Object o = new Object();
+        rs2.setNullObject(o);
+        assertNotNull(rs.getObject(1));
+        assertEquals(o, rs.getObject(1));
+        assertNotNull(rs.getObject("column"));
+        assertEquals(o, rs.getObject("column"));
+        assertNotNull(rs.getObject(1, (Map<String, Class<?>>) null));
+        assertEquals(o, rs.getObject(1, (Map<String, Class<?>>) null));
+        assertNotNull(rs.getObject("column", (Map<String, Class<?>>) null));
+        assertEquals(o, rs.getObject("column", (Map<String, Class<?>>) null));
+    }
+
+    /**
+     * Tests the setNullShort implementation.
+     */
+    public void testSetNullShort() throws SQLException {
+
+        assertEquals((short) 0, rs2.getNullShort());
+        // Set what gets returned to something other than the default
+        short s = (short) 10;
+        rs2.setNullShort(s);
+        assertEquals(s, rs.getShort(1));
+        assertEquals(s, rs.getShort("column"));
+
+    }
+
+    /**
+     * Tests the setNullString implementation.
+     */
+    public void testSetNullString() throws SQLException {
+        assertEquals(null, rs2.getNullString());
+        // Set what gets returned to something other than the default
+        String s = "hello, world";
+        rs2.setNullString(s);
+        assertEquals(s, rs.getString(1));
+        assertEquals(s, rs.getString("column"));
+    }
+
+    /**
+     * Tests the setNullRef implementation.
+     */
+    public void testSetNullRef() throws SQLException {
+        assertNull(rs2.getNullRef());
+        // Set what gets returned to something other than the default
+        Ref ref = new SqlNullCheckedResultSetMockRef();
+        rs2.setNullRef(ref);
+        assertNotNull(rs.getRef(1));
+        assertEquals(ref, rs.getRef(1));
+        assertNotNull(rs.getRef("column"));
+        assertEquals(ref, rs.getRef("column"));
+    }
+
+    /**
+     * Tests the setNullTime implementation.
+     */
+    public void testSetNullTime() throws SQLException {
+        assertEquals(null, rs2.getNullTime());
+        // Set what gets returned to something other than the default
+        Time time = new Time(new java.util.Date().getTime());
+        rs2.setNullTime(time);
+        assertNotNull(rs.getTime(1));
+        assertEquals(time, rs.getTime(1));
+        assertNotNull(rs.getTime("column"));
+        assertEquals(time, rs.getTime("column"));
+        assertNotNull(rs.getTime(1, Calendar.getInstance()));
+        assertEquals(time, rs.getTime(1, Calendar.getInstance()));
+        assertNotNull(rs.getTime("column", Calendar.getInstance()));
+        assertEquals(time, rs.getTime("column", Calendar.getInstance()));
+    }
+
+    /**
+     * Tests the setNullTimestamp implementation.
+     */
+    public void testSetNullTimestamp() throws SQLException {
+        assertEquals(null, rs2.getNullTimestamp());
+        // Set what gets returned to something other than the default
+        Timestamp ts = new Timestamp(new java.util.Date().getTime());
+        rs2.setNullTimestamp(ts);
+        assertNotNull(rs.getTimestamp(1));
+        assertEquals(ts, rs.getTimestamp(1));
+        assertNotNull(rs.getTimestamp("column"));
+        assertEquals(ts, rs.getTimestamp("column"));
+        assertNotNull(rs.getTimestamp(1, Calendar.getInstance()));
+        assertEquals(ts, rs.getTimestamp(1, Calendar.getInstance()));
+        assertNotNull(rs.getTimestamp("column", Calendar.getInstance()));
+        assertEquals(ts, rs.getTimestamp("column", Calendar.getInstance()));
+    }
+
+}
+
+class SqlNullUncheckedMockResultSet implements InvocationHandler {
+
+    /**
+     * Always return false for booleans, 0 for numerics, and null for Objects.
+     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method,
java.lang.Object[])
+     */
+    @Override
+    public Object invoke(Object proxy, Method method, Object[] args)
+            throws Throwable {
+
+        Class<?> returnType = method.getReturnType();
+
+        if (method.getName().equals("wasNull")) {
+            return Boolean.TRUE;
+
+        } else if (returnType.equals(Boolean.TYPE)) {
+            return Boolean.FALSE;
+
+        } else if (returnType.equals(Integer.TYPE)) {
+            return Integer.valueOf(0);
+
+        } else if (returnType.equals(Short.TYPE)) {
+            return Short.valueOf((short) 0);
+
+        } else if (returnType.equals(Double.TYPE)) {
+            return new Double(0);
+
+        } else if (returnType.equals(Long.TYPE)) {
+            return Long.valueOf(0);
+
+        } else if (returnType.equals(Byte.TYPE)) {
+            return Byte.valueOf((byte) 0);
+
+        } else if (returnType.equals(Float.TYPE)) {
+            return new Float(0);
+
+        } else {
+            return null;
+        }
+    }
+}
+
+class SqlNullCheckedResultSetMockBlob implements Blob {
+
+    @Override
+    public InputStream getBinaryStream() throws SQLException {
+        return new ByteArrayInputStream(new byte[0]);
+    }
+
+    @Override
+    public byte[] getBytes(long param, int param1) throws SQLException {
+        return new byte[0];
+    }
+
+    @Override
+    public long length() throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public long position(byte[] values, long param) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public long position(Blob blob, long param) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public void truncate(long len) throws SQLException {
+
+    }
+
+    @Override
+    public int setBytes(long pos, byte[] bytes) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public int setBytes(long pos, byte[] bytes, int offset, int len)
+            throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public OutputStream setBinaryStream(long pos) throws SQLException {
+        return null;
+    }
+
+    /**
+     * @throws SQLException
+     */
+    @Override
+    public void free() throws SQLException {
+
+    }
+
+    /**
+     * @throws SQLException
+     */
+    @Override
+    public InputStream getBinaryStream(long pos, long length) throws SQLException {
+        return null;
+    }
+
+}
+
+class SqlNullCheckedResultSetMockClob implements Clob {
+
+    @Override
+    public InputStream getAsciiStream() throws SQLException {
+        return null;
+    }
+
+    @Override
+    public Reader getCharacterStream() throws SQLException {
+        return null;
+    }
+
+    @Override
+    public String getSubString(long param, int param1) throws SQLException {
+        return "";
+    }
+
+    @Override
+    public long length() throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public long position(Clob clob, long param) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public long position(String str, long param) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public void truncate(long len) throws SQLException {
+
+    }
+
+    @Override
+    public OutputStream setAsciiStream(long pos) throws SQLException {
+        return null;
+    }
+
+    @Override
+    public Writer setCharacterStream(long pos) throws SQLException {
+        return null;
+    }
+
+    @Override
+    public int setString(long pos, String str) throws SQLException {
+        return 0;
+    }
+
+    @Override
+    public int setString(long pos, String str, int offset, int len)
+            throws SQLException {
+        return 0;
+    }
+
+    /**
+     * @throws SQLException
+     */
+    @Override
+    public void free() throws SQLException {
+
+    }
+
+    /**
+     * @throws SQLException
+     */
+    @Override
+    public Reader getCharacterStream(long pos, long length) throws SQLException {
+        return null;
+    }
+
+}
+
+class SqlNullCheckedResultSetMockRef implements Ref {
+
+    @Override
+    public String getBaseTypeName() throws SQLException {
+        return "";
+    }
+
+    @Override
+    public Object getObject() throws SQLException {
+        return null;
+    }
+
+    @Override
+    public void setObject(Object value) throws SQLException {
+
+    }
+
+    @Override
+    public Object getObject(Map<String,Class<?>> map) throws SQLException {
+        return null;
+    }
+
+}

http://git-wip-us.apache.org/repos/asf/commons-dbutils/blob/41d6d58c/src/test/java/org/apache/commons/dbutils2/wrappers/StringTrimmedResultSetTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/dbutils2/wrappers/StringTrimmedResultSetTest.java
b/src/test/java/org/apache/commons/dbutils2/wrappers/StringTrimmedResultSetTest.java
new file mode 100644
index 0000000..c5de076
--- /dev/null
+++ b/src/test/java/org/apache/commons/dbutils2/wrappers/StringTrimmedResultSetTest.java
@@ -0,0 +1,71 @@
+/*
+ * 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.dbutils2.wrappers;
+
+import java.sql.ResultSet;
+import java.sql.SQLException;
+
+import org.apache.commons.dbutils2.BaseTestCase;
+import org.apache.commons.dbutils2.MockResultSet;
+import org.apache.commons.dbutils2.ProxyFactory;
+import org.apache.commons.dbutils2.wrappers.SqlNullCheckedResultSet;
+import org.apache.commons.dbutils2.wrappers.StringTrimmedResultSet;
+
+/**
+ * StringTrimmedResultSetTest
+ */
+public class StringTrimmedResultSetTest extends BaseTestCase {
+
+    @Override
+    public void setUp() throws Exception {
+        super.setUp();
+        this.rs = StringTrimmedResultSet.wrap(this.rs);
+    }
+
+    public void testGetString() throws SQLException {
+        this.rs.next();
+        assertEquals("notInBean", rs.getString(4));
+    }
+
+    public void testGetObject() throws SQLException {
+        this.rs.next();
+        assertEquals("notInBean", rs.getObject(4));
+    }
+
+    /**
+     * Make sure 2 wrappers work together.
+     * @throws SQLException if a database access error occurs
+     */
+    public void testMultipleWrappers() throws Exception {
+        // Create a ResultSet with data
+        Object[][] rows = new Object[][] { { null }
+        };
+        ResultSet rs = MockResultSet.create(metaData, rows);
+
+        // Wrap the ResultSet with a null checked version
+        SqlNullCheckedResultSet ncrs = new SqlNullCheckedResultSet(rs);
+        ncrs.setNullString("   trim this   ");
+        rs = ProxyFactory.instance().createResultSet(ncrs);
+
+        // Wrap the wrapper with a string trimmed version
+        rs = StringTrimmedResultSet.wrap(rs);
+
+        rs.next();
+        assertEquals("trim this", rs.getString(1));
+    }
+
+}


Mime
View raw message