modules/sql/src/test/java/org/apache/harmony/sql/tests/internal/rowset/AbstractRowSetImplTest.java

/* 
 * 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.harmony.sql.tests.internal.rowset;

import java.io.ByteArrayInputStream;
import java.io.CharArrayReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Date;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.Calendar;
import java.util.Locale;

import javax.sql.RowSetEvent;
import javax.sql.RowSetListener;

import org.apache.harmony.sql.internal.rowset.AbstractRowSetImpl;

import junit.framework.TestCase;

public class AbstractRowSetImplTest extends TestCase {
    private AbstractRowSetImpl rowset;

    private Object[] params;

    public void setUp() {
        rowset = new AbstractRowSetImpl();
    }

    public void tearDown() {
        rowset = null;
    }

    private class MockRowSetListener implements RowSetListener {
        boolean cursorMoved;

        boolean rowChanged;

        boolean rowsetChanged;

        public void cursorMoved(RowSetEvent theEvent) {
            cursorMoved = cursorMoved ? false : true;

        }

        public void rowChanged(RowSetEvent theEvent) {
            rowChanged = rowChanged ? false : true;
        }

        public void rowSetChanged(RowSetEvent theEvent) {
            rowsetChanged = rowsetChanged ? false : true;
        }

    }

    /**
     * @add tests
     *      {@link javax.sql.rowset.BaseRowSet#addRowSetListener(javax.sql.RowSetListener)}
     * @add tests
     *      {@link javax.sql.rowset.BaseRowSet#removeRowSetListener(RowSetListener)}
     */
    public void test_addRowSetListener_Ljavax_sql_RowsetListener()
            throws SQLException {
        final class MockAbstractRowSetImpl extends AbstractRowSetImpl {

            /**
             * 
             */
            private static final long serialVersionUID = 1L;

            protected void notifyCursorMoved() throws SQLException {
                super.notifyCursorMoved();
            }

            protected void notifyRowChanged() throws SQLException {
                super.notifyRowChanged();
            }

            protected void notifyRowSetChanged() throws SQLException {
                super.notifyRowSetChanged();
            }

        }
        MockRowSetListener listener = new MockRowSetListener();
        MockAbstractRowSetImpl rowset = new MockAbstractRowSetImpl();
        rowset.addRowSetListener(listener);
        assertFalse(listener.cursorMoved);
        assertFalse(listener.rowChanged);
        assertFalse(listener.rowsetChanged);
        rowset.notifyCursorMoved();
        assertTrue(listener.cursorMoved);
        rowset.notifyRowChanged();
        assertTrue(listener.rowChanged);
        rowset.notifyRowSetChanged();
        assertTrue(listener.rowsetChanged);

        // this call won't make any effect
        rowset.removeRowSetListener(null);
        rowset.notifyCursorMoved();
        rowset.notifyRowChanged();
        rowset.notifyRowSetChanged();
        assertFalse(listener.cursorMoved);
        assertFalse(listener.rowChanged);
        assertFalse(listener.rowsetChanged);

        // this call will remove the registered listener
        rowset.removeRowSetListener(listener);
        rowset.notifyCursorMoved();
        rowset.notifyRowChanged();
        rowset.notifyRowSetChanged();
        assertFalse(listener.cursorMoved);
        assertFalse(listener.rowChanged);
        assertFalse(listener.rowsetChanged);
    }

    /**
     *@add tests {@link javax.sql.rowset.BaseRowSet#getUsername()}.
     */
    public void test_getUsername() {
        assertNull("username should init as null", rowset.getUsername());
    }

    /**
     * @add tests {@link javax.sql.rowset.BaseRowSet#getPassword()}.
     */
    public void test_getPassword() {
        assertNull("password should init as null", rowset.getPassword());
    }

    /**
     * Test method for {@link javax.sql.rowset.BaseRowSet#setInt(int, int)}.
     */
    public void test_setInt_II() throws SQLException {
        try {
            rowset.setInt(0, 0);
            fail("should throw SQLException");
        } catch (SQLException sqlE) {
            // expected
        }
        rowset.setInt(1, 1);
        params = rowset.getParams();
        assertEquals("set int failure", 1, ((Integer) params[0]).intValue());

    }

    /**
     * Test method for {@link javax.sql.rowset.BaseRowSet#setLong(int, long)}.
     */
    public void test_setLong_IJ() throws SQLException {
        try {
            rowset.setLong(0, 0L);
            fail("should throw SQLException");
        } catch (SQLException ex) {
            // expected
        }
        rowset.setLong(1, 1000000L);
        params = rowset.getParams();
        assertEquals("set long failure", 1000000L, ((Long) params[0])
                .longValue());
    }

    /**
     * Test method for {@link javax.sql.rowset.BaseRowSet#setFloat(int, float)}.
     */
    public void test_setFloat_IF() throws SQLException {
        try {
            rowset.setFloat(0, 0f);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setFloat(1, 0.5f);
        params = rowset.getParams();
        assertEquals("set float failure", 0.5f, ((Float) params[0])
                .floatValue());
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setDouble(int, double)}.
     * 
     * @throws SQLException
     */
    public void test_setDouble_ID() throws SQLException {
        try {
            rowset.setDouble(0, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setDouble(1, 1.5);
        params = rowset.getParams();
        assertEquals("set double failure", 1.5, ((Double) params[0])
                .doubleValue());
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setBigDecimal(int, java.math.BigDecimal)}
     * 
     * @throws SQLException
     */
    public void test_setBigDecimal_ILjava_math_Bigdecimal() throws SQLException {
        BigDecimal decimal = new BigDecimal(1000);
        try {
            rowset.setBigDecimal(0, decimal);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setBigDecimal(1, decimal);
        params = rowset.getParams();
        assertEquals("set big decimal failure", decimal, (BigDecimal) params[0]);
    }

    /**
     * Test method for {@link javax.sql.rowset.BaseRowSet#setBytes(int, byte[])}
     * 
     * @throws SQLException
     */
    public void test_setBytes_IB() throws SQLException {
        try {
            rowset.setBytes(0, null);
        } catch (SQLException e) {
            // expected
        }
        byte[] bytes = new byte[] { (byte) 1, (byte) 2 };
        rowset.setBytes(1, bytes);
        params = rowset.getParams();
        assertEquals("set bytes failure", bytes, ((byte[]) params[0]));
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setDate(int, java.sql.Date)}.
     * 
     * @throws SQLException
     */
    public void test_setDate_ILjava_sql_Date() throws SQLException {
        Date date = new Date(100000000000L);
        try {
            rowset.setDate(0, date);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setDate(1, date);
        params = rowset.getParams();
        assertEquals("setDate(int,Date) failure", date, (Date) params[0]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setTime(int, java.sql.Time)}.
     * 
     * @throws SQLException
     */
    public void test_setTime_ILjava_sql_Time() throws SQLException {
        Time time = new Time(1000000000L);
        try {
            rowset.setTime(0, time);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setTime(1, time);
        params = rowset.getParams();
        assertEquals("setTime(int,Time) failure", time, (Time) params[0]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setTimestamp(int, java.sql.Timestamp)}
     * 
     * @throws SQLException
     */
    public void test_setTimestamp_ILjava_sql_Timestamp() throws SQLException {
        Timestamp stamp = new Timestamp(10000000000L);
        try {
            rowset.setTimestamp(0, stamp);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setTimestamp(1, stamp);
        params = rowset.getParams();
        assertEquals("setTimeStamp(int,Timestamp) failure", stamp,
                (Timestamp) params[0]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setAsciiStream(int, java.io.InputStream, int)}
     * 
     * @throws SQLException
     * @throws IOException
     */
    public void test_setAsciiStream_ILjava_io_InputStreamI()
            throws SQLException, IOException {
        InputStream in = new ByteArrayInputStream(new byte[] { (byte) 1,
                (byte) 10 });
        try {
            rowset.setAsciiStream(0, null, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        try {
            rowset.setAsciiStream(0, in, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setAsciiStream(1, in, 2);
        params = rowset.getParams();
        Object[] array = (Object[]) params[0];
        assertEquals("first element in params " + array[0]
                + " did not equal to Inputstream", in, (InputStream) array[0]);
        in.close();
        assertEquals("second element in params " + array[1]
                + " did not equal to 2", 2, array[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setBinaryStream(int, java.io.InputStream, int)}
     * 
     * @throws SQLException
     * @throws IOException
     */
    public void test_setBinaryStream_ILjava_io_InputStreamI()
            throws SQLException, IOException {
        InputStream in = new ByteArrayInputStream(new byte[] { (byte) 1,
                (byte) 10 });
        try {
            rowset.setBinaryStream(0, null, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        try {
            rowset.setBinaryStream(0, in, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setBinaryStream(1, in, 2);
        params = rowset.getParams();
        Object[] array = (Object[]) params[0];
        assertEquals("first element in params " + array[0]
                + " did not equal to Inputstream", in, (InputStream) array[0]);
        in.close();
        assertEquals("second element in params " + array[1]
                + " did not equal to 2", 2, array[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setUnicodeStream(int, java.io.InputStream, int)}
     * 
     * @throws SQLException
     */
    @SuppressWarnings("deprecation")
    public void test_setUnicodeStream_ILjava_io_InputStreamI()
            throws SQLException {
        InputStream in = new ByteArrayInputStream(new byte[] { (byte) 1,
                (byte) 10 });
        try {
            rowset.setUnicodeStream(0, null, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        try {
            rowset.setUnicodeStream(0, in, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setUnicodeStream(1, in, 2);
        params = rowset.getParams();
        Object[] array = (Object[]) params[0];
        assertEquals("first element in params " + array[0]
                + " did not equal to Inputstream", in, (InputStream) array[0]);
        assertEquals("second element in params " + array[1]
                + " did not equal to 2", 2, array[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setCharacterStream(int, java.io.Reader, int)}
     * 
     * @throws SQLException
     */
    public void test_setCharacterStream_ILjava_io_ReaderI() throws SQLException {
        Reader reader = new CharArrayReader(new char[] { 'a', 'b' });
        try {
            rowset.setCharacterStream(0, null, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        try {
            rowset.setCharacterStream(0, reader, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setCharacterStream(1, reader, 2);
        // rowset.getCharacterStream(1);
        params = rowset.getParams();
        Object[] array = (Object[]) params[0];
        assertEquals("first element in params " + array[0]
                + " did not equal to Inputstream", reader, (Reader) array[0]);
        assertEquals("second element in params " + array[1]
                + " did not equal to 2", 2, array[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setObject(int, java.lang.Object, int, int)}
     * 
     * @throws SQLException
     */
    public void test_setObject_ILjava_lang_ObjectII() throws SQLException {
        try {
            rowset.setObject(0, null, 0, 0);
            fail("should throw SQLExceptions");
        } catch (SQLException e) {
            // expected
        }
        rowset.setObject(1, null, 0, 0);// should pass
        rowset.setObject(2, new Float(0.55f), Types.NUMERIC, 0);// should pass
        rowset.setObject(3, new Double(100.0003), Types.DECIMAL, 4);
        params = rowset.getParams();
        Object[] array1 = (Object[]) params[0];
        assertNull(array1[0]);
        Object[] array2 = (Object[]) params[1];
        assertEquals(0.55f, ((Float) array2[0]).floatValue());
        assertEquals(Types.NUMERIC, array2[1]);
        Object[] array3 = (Object[]) params[2];
        assertEquals(100.0003, ((Double) array3[0]).doubleValue());
        assertEquals(Types.DECIMAL, array3[1]);
        assertEquals(4, array3[2]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setObject(int, java.lang.Object, int)}
     * 
     * @throws SQLException
     */
    public void test_setObject_ILjava_lang_ObjectI() throws SQLException {
        try {
            rowset.setObject(0, null, 0);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setObject(1, null, 0);// should pass
        rowset.setObject(1, new Integer(10), Types.VARCHAR);// should pass
        rowset.setObject(1, new Integer(10), Types.INTEGER);
        params = rowset.getParams();
        Object[] array = (Object[]) params[0];
        assertEquals(10, ((Integer) array[0]).intValue());
        assertEquals(Types.INTEGER, array[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setObject(int, java.lang.Object)}.
     * 
     * @throws SQLException
     */
    public void test_setObject_IntLjava_lang_Object() throws SQLException {
        try {
            rowset.setObject(0, null);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setObject(1, new String("test"));
        params = rowset.getParams();
        assertEquals("test", (String) params[0]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setTime(int, java.sql.Time, java.util.Calendar)}
     * 
     * @throws SQLException
     */
    public void test_setTime_ILjava_sql_TimeLjava_util_Calendar()
            throws SQLException {
        try {
            rowset.setTimestamp(0, null, null);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        rowset.setTime(1, null, null);// should pass
        Time t = new Time(100000L);
        Calendar cal = Calendar.getInstance(Locale.CHINA);
        rowset.setTime(2, t, cal);
        params = rowset.getParams();
        Object[] array1 = (Object[]) params[0];
        assertNull(array1[0]);
        assertNull(array1[1]);
        Object[] array2 = (Object[]) params[1];
        assertEquals(t, array2[0]);
        assertEquals(cal, array2[1]);
    }

    /**
     * Test method for
     * {@link javax.sql.rowset.BaseRowSet#setTimestamp(int, java.sql.Timestamp, java.util.Calendar)}
     * 
     * @throws SQLException
     */
    public void test_setTimestamp_ILjava_sql_TimestampLjava_util_Calendar()
            throws SQLException {
        try {
            rowset.setTimestamp(0, null, null);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        Timestamp ts = new Timestamp(1000000000000000L);
        Calendar cal = Calendar.getInstance(Locale.CHINA);
        rowset.setTimestamp(1, null, null);
        rowset.setTimestamp(2, ts, cal);
        params = rowset.getParams();
        Object[] array1 = (Object[]) params[0];
        Object[] array2 = (Object[]) params[1];
        assertNull(array1[0]);
        assertNull(array1[1]);
        assertEquals(ts, array2[0]);
        assertEquals(cal, array2[1]);
    }

    /**
     * @throws SQLException
     * @add tests
     *      {@link javax.sql.rowset.BaseRowSet#setDate(int, Date, Calendar)}
     */
    public void test_setDate_ILjava_sql_DateLjava_util_Calendar()
            throws SQLException {
        try {
            rowset.setDate(0, null, null);
            fail("should throw SQLException");
        } catch (SQLException e) {
            // expected
        }
        Date date = new Date(10000000000L);
        Calendar cal = Calendar.getInstance(Locale.CHINA);
        rowset.setDate(1, null, null);
        rowset.setDate(2, null, cal);
        rowset.setDate(3, date, null);
        rowset.setDate(4, date, cal);
        params = rowset.getParams();
        Object[] array1 = (Object[]) params[0];
        Object[] array2 = (Object[]) params[1];
        Object[] array3 = (Object[]) params[2];
        Object[] array4 = (Object[]) params[3];
        assertNull(array1[0]);
        assertNull(array1[1]);
        assertNull(array2[0]);
        assertEquals(cal, array2[1]);
        assertEquals(date, array3[0]);
        assertNull(array3[1]);
        assertEquals(date, array4[0]);
        assertEquals(cal, array4[1]);
    }

    /**
     * @throws SQLException
     * @add tests {@link javax.sql.rowset.BaseRowSet#setQueryTimeout(int)}
     */
    public void test_setQueryTimeOut_I() throws SQLException {
        try {
            rowset.setQueryTimeout(-1);
        } catch (SQLException e) {
            // expected
        }
        rowset.setQueryTimeout(10);
        assertEquals(10, rowset.getQueryTimeout());
    }

}