test/rowset/CommonRowSetTests.java

/*
 * Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
package test.rowset;

import java.io.InputStream;
import java.io.Reader;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.Date;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.RowId;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.RowSet;
import javax.sql.rowset.BaseRowSet;
import javax.sql.rowset.CachedRowSet;
import javax.sql.rowset.RowSetFactory;
import javax.sql.rowset.RowSetMetaDataImpl;
import javax.sql.rowset.RowSetProvider;
import org.testng.Assert;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import util.BaseTest;
import util.StubBlob;
import util.StubClob;
import util.StubNClob;
import util.StubSQLXML;

public abstract class CommonRowSetTests extends BaseTest {

    protected final String stubProvider = "util.StubSyncProvider";
    protected final String query = "SELECT * FROM SUPERHEROS";
    private final String url = "jdbc:derby://localhost:1527/myDB";
    private final String dsName = "jdbc/myDB";
    private final String user = "Bruce Wayne";
    private final String password = "The Dark Knight";
    protected final String COFFEE_HOUSES_TABLE = "COFFEE_HOUSES";
    protected final String COFFEES_TABLE = "COFFEES";
    protected final int COFFEE_HOUSES_ROWS = 14;
    protected final int COFFEES_ROWS = 5;
    protected final Object[] COFFEES_PRIMARY_KEYS = {1, 2, 3, 4, 5};
    protected final Object[] COFFEE_HOUSES_PRIMARY_KEYS = {
        10023, 33002, 10040, 32001, 10042, 10024, 10039, 10041,
        33005, 33010, 10035, 10037, 10034, 32004
    };

    /*
     * COFFEES_HOUSES Table column names
     */
    protected final String[] COFFEE_HOUSES_COLUMN_NAMES = {
        "STORE_ID", "CITY", "COFFEE", "MERCH", "TOTAL"
    };

    /*
     * COFFEES Table column names
     */
    protected final String[] COFFEES_COLUMN_NAMES = {
        "COF_ID", "COF_NAME", "SUP_ID", "PRICE", "SALES", "TOTAL"
    };

    protected RowSetFactory rsf;

    public CommonRowSetTests() {
        try {
            rsf = RowSetProvider.newFactory();
        } catch (SQLException ex) {
            Assert.fail(ex.getMessage());
        }
    }

    // Create an instance of the RowSet we are using
    protected abstract <T extends RowSet> T newInstance() throws SQLException;

    //DataProvider to use for common tests

    /*
     * DataProvider used to specify the value to set and check for the
     * methods for fetch direction
     */
    @DataProvider(name = "rowSetFetchDirection")
    protected Object[][] rowSetFetchDirection() throws Exception {
        RowSet rs = newInstance();
        return new Object[][]{
            {rs, ResultSet.FETCH_FORWARD},
            {rs, ResultSet.FETCH_REVERSE},
            {rs, ResultSet.FETCH_UNKNOWN}
        };
    }

    /*
     * DataProvider used to specify the value to set and check for the
     * methods for Cursor Scroll Type
     */
    @DataProvider(name = "rowSetScrollTypes")
    protected Object[][] rowSetScrollTypes() throws Exception {
        RowSet rs = newInstance();

        return new Object[][]{
            {rs, ResultSet.TYPE_FORWARD_ONLY},
            {rs, ResultSet.TYPE_SCROLL_INSENSITIVE},
            {rs, ResultSet.TYPE_SCROLL_SENSITIVE}
        };
    }

    /*
     * DataProvider used to specify the value to set and check for
     * methods using transaction isolation types
     */
    @DataProvider(name = "rowSetIsolationTypes")
    protected Object[][] rowSetIsolationTypes() throws Exception {
        RowSet rs = newInstance();

        return new Object[][]{
            {rs, Connection.TRANSACTION_NONE},
            {rs, Connection.TRANSACTION_READ_COMMITTED},
            {rs, Connection.TRANSACTION_READ_UNCOMMITTED},
            {rs, Connection.TRANSACTION_REPEATABLE_READ},
            {rs, Connection.TRANSACTION_SERIALIZABLE}
        };
    }

    /*
     * DataProvider used to specify the value to set and check for the
     * methods for Concurrency
     */
    @DataProvider(name = "rowSetConcurrencyTypes")
    protected Object[][] rowSetConcurrencyTypes() throws Exception {
        RowSet rs = newInstance();
        return new Object[][]{
            {rs, ResultSet.CONCUR_READ_ONLY},
            {rs, ResultSet.CONCUR_UPDATABLE}
        };
    }

    /*
     * DataProvider used to specify the value to set and check for
     * methods using boolean values
     */
    @DataProvider(name = "rowSetTrueFalse")
    protected Object[][] rowSetTrueFalse() throws Exception {
        RowSet rs = newInstance();
        return new Object[][]{
            {rs, true},
            {rs, false}
        };
    }
    /*
     * DataProvider used to specify the type of RowSet to use.  We also must
     * initialize the RowSet
     */
    @DataProvider(name = "rowSetType")
    protected Object[][] rowSetType() throws Exception {

        RowSet rs = newInstance();
        return new Object[][]{
            {rs}
        };
    }

    /*
     * Initializes a RowSet containing the COFFEE_HOUSES data
     */
    protected <T extends RowSet> T createCoffeeHousesRowSet() throws SQLException {
        T rs = (T) newInstance();
        initCoffeeHousesMetaData((CachedRowSet) rs);
        createCoffeeHouseRows(rs);
        // Make sure you are not on the insertRow
        rs.moveToCurrentRow();
        return rs;
    }

    /*
     * Initializes a RowSet containing the COFFEE_HOUSES data
     */
    protected <T extends RowSet> T createCoffeesRowSet() throws SQLException {
        T rs = (T) newInstance();
        initCoffeesMetaData((CachedRowSet) rs);
        createCoffeesRows(rs);
        // Make sure you are not on the insertRow
        rs.moveToCurrentRow();
        return rs;
    }

    /*
     * Initializes the COFFEE_HOUSES metadata
     */
    private void initCoffeeHousesMetaData(CachedRowSet crs) throws SQLException {
        RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
        crs.setType(RowSet.TYPE_SCROLL_INSENSITIVE);

        /*
         *  CREATE TABLE COFFEE_HOUSES(
         *   STORE_ID Integer NOT NULL,
         *   CITY VARCHAR(32),
         *   COFFEE INTEGER NOT NULL,
         *   MERCH INTEGER NOT NULL,
         *   TOTAL INTEGER NOT NULL,
         *   PRIMARY KEY (STORE_ID))
         */
        rsmd.setColumnCount(COFFEE_HOUSES_COLUMN_NAMES.length);
        for(int i = 1; i <= COFFEE_HOUSES_COLUMN_NAMES.length; i++){
            rsmd.setColumnName(i, COFFEE_HOUSES_COLUMN_NAMES[i-1]);
            rsmd.setColumnLabel(i, rsmd.getColumnName(i));
        }

        rsmd.setColumnType(1, Types.INTEGER);
        rsmd.setColumnType(2, Types.VARCHAR);
        rsmd.setColumnType(3, Types.INTEGER);
        rsmd.setColumnType(4, Types.INTEGER);
        rsmd.setColumnType(5, Types.INTEGER);
        crs.setMetaData(rsmd);
        crs.setTableName(COFFEE_HOUSES_TABLE);

    }

    /*
     * Add rows to COFFEE_HOUSES table
     */
    protected void createCoffeeHouseRows(RowSet rs) throws SQLException {

        // insert into COFFEE_HOUSES values(10023, 'Mendocino', 3450, 2005, 5455)
        rs.moveToInsertRow();
        rs.updateInt(1, 10023);
        rs.updateString(2, "Mendocino");
        rs.updateInt(3, 3450);
        rs.updateInt(4, 2005);
        rs.updateInt(5, 5455);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(33002, 'Seattle', 4699, 3109, 7808)
        rs.moveToInsertRow();
        rs.updateInt(1, 33002);
        rs.updateString(2, "Seattle");
        rs.updateInt(3, 4699);
        rs.updateInt(4, 3109);
        rs.updateInt(5, 7808);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10040, 'SF', 5386, 2841, 8227)
        rs.moveToInsertRow();
        rs.updateInt(1, 10040);
        rs.updateString(2, "SF");
        rs.updateInt(3, 5386);
        rs.updateInt(4, 2841);
        rs.updateInt(5, 8227);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(32001, 'Portland', 3147, 3579, 6726)
        rs.moveToInsertRow();
        rs.updateInt(1, 32001);
        rs.updateString(2, "Portland");
        rs.updateInt(3, 3147);
        rs.updateInt(4, 3579);
        rs.updateInt(5, 6726);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10042, 'SF', 2863, 1874, 4710)
        rs.moveToInsertRow();
        rs.updateInt(1, 10042);
        rs.updateString(2, "SF");
        rs.updateInt(3, 2863);
        rs.updateInt(4, 1874);
        rs.updateInt(5, 4710);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10024, 'Sacramento', 1987, 2341, 4328)
        rs.moveToInsertRow();
        rs.updateInt(1, 10024);
        rs.updateString(2, "Sacramento");
        rs.updateInt(3, 1987);
        rs.updateInt(4, 2341);
        rs.updateInt(5, 4328);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10039, 'Carmel', 2691, 1121, 3812)
        rs.moveToInsertRow();
        rs.updateInt(1, 10039);
        rs.updateString(2, "Carmel");
        rs.updateInt(3, 2691);
        rs.updateInt(4, 1121);
        rs.updateInt(5, 3812);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10041, 'LA', 1533, 1007, 2540)
        rs.moveToInsertRow();
        rs.updateInt(1, 10041);
        rs.updateString(2, "LA");
        rs.updateInt(3, 1533);
        rs.updateInt(4, 1007);
        rs.updateInt(5, 2540);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(33005, 'Olympia', 2733, 1550, 1550)
        rs.moveToInsertRow();
        rs.updateInt(1, 33005);
        rs.updateString(2, "Olympia");
        rs.updateInt(3, 2733);
        rs.updateInt(4, 1550);
        rs.updateInt(5, 1550);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(33010, 'Seattle', 3210, 2177, 5387)
        rs.moveToInsertRow();
        rs.updateInt(1, 33010);
        rs.updateString(2, "Seattle");
        rs.updateInt(3, 3210);
        rs.updateInt(4, 2177);
        rs.updateInt(5, 5387);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10035, 'SF', 1922, 1056, 2978)
        rs.moveToInsertRow();
        rs.updateInt(1, 10035);
        rs.updateString(2, "SF");
        rs.updateInt(3, 1922);
        rs.updateInt(4, 1056);
        rs.updateInt(5, 2978);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10037, 'LA', 2143, 1876, 4019)
        rs.moveToInsertRow();
        rs.updateInt(1, 10037);
        rs.updateString(2, "LA");
        rs.updateInt(3, 2143);
        rs.updateInt(4, 1876);
        rs.updateInt(5, 4019);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(10034, 'San_Jose', 1234, 1032, 2266)
        rs.moveToInsertRow();
        rs.updateInt(1, 10034);
        rs.updateString(2, "San Jose");
        rs.updateInt(3, 1234);
        rs.updateInt(4, 1032);
        rs.updateInt(5, 2266);
        rs.insertRow();
        // insert into COFFEE_HOUSES values(32004, 'Eugene', 1356, 1112, 2468)
        rs.moveToInsertRow();
        rs.updateInt(1, 32004);
        rs.updateString(2, "Eugene");
        rs.updateInt(3, 1356);
        rs.updateInt(4, 1112);
        rs.updateInt(5, 2468);
        rs.insertRow();
        rs.moveToCurrentRow();
    }

    /*
     * Initializes the COFFEES metadata
     */
    protected void initCoffeesMetaData(CachedRowSet crs) throws SQLException {
        RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl();
        crs.setType(RowSet.TYPE_SCROLL_INSENSITIVE);

        /*
         *  CREATE TABLE COFFEES (
         *   COF_ID INTEGER NOT NULL,
         *   COF_NAME VARCHAR(32) NOT NULL,
         *   SUP_ID INTEGER NOT NULL,
         *   PRICE NUMBERIC(10,2 NOT NULL,
         *   SALES INTEGER NOT NULL,
         *   TOTAL INTEGER NOT NULL,
         *   PRIMARY KEY (COF_ID),
         *   FOREIGN KEY (SUP_ID) REFERENCES SUPPLIERS (SUP_ID) )
         */
        rsmd.setColumnCount(COFFEES_COLUMN_NAMES.length);
        for(int i = 1; i <= COFFEES_COLUMN_NAMES.length; i++){
            rsmd.setColumnName(i, COFFEES_COLUMN_NAMES[i-1]);
            rsmd.setColumnLabel(i, rsmd.getColumnName(i));
        }

        rsmd.setColumnType(1, Types.INTEGER);
        rsmd.setColumnType(2, Types.VARCHAR);
        rsmd.setColumnType(3, Types.INTEGER);
        rsmd.setColumnType(4, Types.NUMERIC);
        rsmd.setPrecision(4, 10);
        rsmd.setScale(4, 2);
        rsmd.setColumnType(5, Types.INTEGER);
        rsmd.setColumnType(6, Types.INTEGER);
        crs.setMetaData(rsmd);
        crs.setTableName(COFFEES_TABLE);

    }

    /*
     * Add rows to COFFEES table
     */
    protected void createCoffeesRows(RowSet rs) throws SQLException {

        // insert into COFFEES values(1, 'Colombian', 101, 7.99, 0, 0)
        rs.moveToInsertRow();
        rs.updateInt(1, 1);
        rs.updateString(2, "Colombian");
        rs.updateInt(3, 101);
        rs.updateBigDecimal(4, BigDecimal.valueOf(7.99));
        rs.updateInt(5, 0);
        rs.updateInt(6, 0);
        rs.insertRow();
        // insert into COFFEES values(2, 'French_Roast', 49, 8.99, 0, 0)
        rs.moveToInsertRow();
        rs.updateInt(1, 2);
        rs.updateString(2, "French_Roast");
        rs.updateInt(3, 49);
        rs.updateBigDecimal(4, BigDecimal.valueOf(8.99));
        rs.updateInt(5, 0);
        rs.updateInt(6, 0);
        rs.insertRow();
        // insert into COFFEES values(3, 'Espresso', 150, 9.99, 0, 0)
        rs.moveToInsertRow();
        rs.updateInt(1, 3);
        rs.updateString(2, "Espresso");
        rs.updateInt(3, 150);
        rs.updateBigDecimal(4, BigDecimal.valueOf(9.99));
        rs.updateInt(5, 0);
        rs.updateInt(6, 0);
        rs.insertRow();
        // insert into COFFEES values(4, 'Colombian_Decaf', 101, 8.99, 0, 0)
        rs.moveToInsertRow();
        rs.updateInt(1, 4);
        rs.updateString(2, "Colombian_Decaf");
        rs.updateInt(3, 101);
        rs.updateBigDecimal(4, BigDecimal.valueOf(8.99));
        rs.updateInt(5, 0);
        rs.updateInt(6, 0);
        rs.insertRow();
        // insert into COFFEES values(5, 'French_Roast_Decaf', 049, 9.99, 0, 0)
        rs.moveToInsertRow();
        rs.updateInt(1, 5);
        rs.updateString(2, "French_Roast_Decaf");
        rs.updateInt(3, 49);
        rs.updateBigDecimal(4, BigDecimal.valueOf(9.99));
        rs.updateInt(5, 0);
        rs.updateInt(6, 0);
        rs.insertRow();

    }


    /*
     * Utility method to return the Primary Keys for a RowSet.  The Primary
     * keys are assumed to be in the first column of the RowSet
     */
    protected Object[] getPrimaryKeys(ResultSet rs) throws SQLException {
        List<? super Object> result = new ArrayList<>();
        if (rs == null) {
            return null;
        }
        rs.beforeFirst();
        while (rs.next()) {
            result.add(rs.getInt(1));
        }
        return result.toArray();
    }

    /*
     * Utility method to display the RowSet and will return the row count
     * it found
     */
    protected int displayResults(ResultSet rs) throws SQLException {
        int rows = 0;
        ResultSetMetaData rsmd = rs.getMetaData();
        int cols = rsmd.getColumnCount();
        if (rs != null) {
            rs.beforeFirst();
            while (rs.next()) {
                rows++;

                for (int i = 0; i < cols; i++) {
                    System.out.print(rs.getString(i + 1) + " ");
                }
                System.out.println();
            }
        }

        return rows;
    }


     // Insert common tests here

    /*
     * Validate that getCommand() returns null by default
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0000(RowSet rs) {
        assertNull(rs.getCommand());
    }

    /*
     * Validate that getCommand() returns command specified to setCommand
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0001(RowSet rs) throws Exception {
        rs.setCommand(query);
        assertTrue(rs.getCommand().equals(query));
    }


    /*
     * Validate that getCurrency() returns the correct default value
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0002(RowSet rs) throws Exception {
        assertTrue(rs.getConcurrency() == ResultSet.CONCUR_UPDATABLE);
    }

    /*
     * Validate that getCurrency() returns the correct value
     * after a call to setConcurrency())
     */
    @Test(dataProvider = "rowSetConcurrencyTypes")
    public void commonRowSetTest0003(RowSet rs, int concurType) throws Exception {
        rs.setConcurrency(concurType);
        assertTrue(rs.getConcurrency() == concurType);
    }

    /*
     * Validate that getCurrency() throws a SQLException for an invalid value
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0004(RowSet rs) throws Exception {
        rs.setConcurrency(ResultSet.CLOSE_CURSORS_AT_COMMIT);
    }

    /*
     * Validate that getDataSourceName() returns null by default
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0005(RowSet rs) throws Exception {
        assertTrue(rs.getDataSourceName() == null);
    }

    /*
     * Validate that getDataSourceName() returns the value specified
     * by setDataSourceName() and getUrl() returns null
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0006(RowSet rs) throws Exception {
        rs.setUrl(url);
        rs.setDataSourceName(dsName);
        assertTrue(rs.getDataSourceName().equals(dsName));
        assertNull(rs.getUrl());
    }

    /*
     * Validate that setDataSourceName() throws a SQLException for an empty
     * String specified for the data source name
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0007(RowSet rs) throws Exception {
        String dsname = "";
        rs.setDataSourceName(dsname);
    }

    /*
     * Validate that getEscapeProcessing() returns false by default
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0008(RowSet rs) throws Exception {
        assertTrue(rs.getEscapeProcessing());
    }

    /*
     * Validate that getEscapeProcessing() returns value set by
     * setEscapeProcessing()
     */
    @Test(dataProvider = "rowSetTrueFalse")
    public void commonRowSetTest0009(RowSet rs, boolean val) throws Exception {
        rs.setEscapeProcessing(val);
        assertTrue(rs.getEscapeProcessing() == val);
    }

    /*
     * Validate that getFetchDirection() returns the correct default value
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0010(RowSet rs) throws Exception {
        assertTrue(rs.getFetchDirection() == ResultSet.FETCH_FORWARD);
    }

    /*
     * Validate that getFetchDirection() returns the value set by
     * setFetchDirection()
     */
    @Test(dataProvider = "rowSetFetchDirection")
    public void commonRowSetTest0011(RowSet rs, int direction) throws Exception {
        rs.setFetchDirection(direction);
        assertTrue(rs.getFetchDirection() == direction);
    }

    /*
     * Validate that setFetchSize() throws a SQLException for an invalid value
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0013(RowSet rs) throws Exception {
        rs.setFetchSize(-1);
    }

    /*
     * Validate that setFetchSize() throws a SQLException for a
     * value greater than getMaxRows()
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0014(RowSet rs) throws Exception {
        rs.setMaxRows(5);
        rs.setFetchSize(rs.getMaxRows() + 1);
    }

    /*
     * Validate that getFetchSize() returns the correct value after
     * setFetchSize() has been called
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0015(RowSet rs) throws Exception {
        int maxRows = 150;
        rs.setFetchSize(0);
        assertTrue(rs.getFetchSize() == 0);
        rs.setFetchSize(100);
        assertTrue(rs.getFetchSize() == 100);
        rs.setMaxRows(maxRows);
        rs.setFetchSize(maxRows);
        assertTrue(rs.getFetchSize() == maxRows);
    }

    /*
     * Validate that setMaxFieldSize() throws a SQLException for an invalid value
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0016(RowSet rs) throws Exception {
        rs.setMaxFieldSize(-1);
    }

    /*
     * Validate that getMaxFieldSize() returns the value set by
     * setMaxFieldSize()
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0017(RowSet rs) throws Exception {
        rs.setMaxFieldSize(0);
        assertTrue(rs.getMaxFieldSize() == 0);
        rs.setMaxFieldSize(100);
        assertTrue(rs.getMaxFieldSize() == 100);
        rs.setMaxFieldSize(50);
        assertTrue(rs.getMaxFieldSize() == 50);
    }

    /*
     * Validate that isReadOnly() returns value set by
     * setReadOnly()
     */
    @Test(dataProvider = "rowSetTrueFalse")
    public void commonRowSetTest0018(RowSet rs, boolean val) throws Exception {
        rs.setReadOnly(val);
        assertTrue(rs.isReadOnly() == val);
    }

    /*
     * Validate that getTransactionIsolation() returns value set by
     * setTransactionIsolation()
     */
    @Test(dataProvider = "rowSetIsolationTypes")
    public void commonRowSetTest0019(RowSet rs, int val) throws Exception {
        rs.setTransactionIsolation(val);
        assertTrue(rs.getTransactionIsolation() == val);
    }

    /*
     * Validate that getType() returns value set by setType()
     */
    @Test(dataProvider = "rowSetScrollTypes")
    public void commonRowSetTest0020(RowSet rs, int val) throws Exception {
        rs.setType(val);
        assertTrue(rs.getType() == val);
    }

    /*
     * Validate that getEscapeProcessing() returns value set by
     * setEscapeProcessing()
     */
    @Test(dataProvider = "rowSetTrueFalse")
    public void commonRowSetTest0021(BaseRowSet rs, boolean val) throws Exception {
        rs.setShowDeleted(val);
        assertTrue(rs.getShowDeleted() == val);
    }

    /*
     * Validate that getTypeMap() returns same value set by
     * setTypeMap()
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0022(RowSet rs) throws Exception {
        Map<String, Class<?>> map = new HashMap<>();
        map.put("SUPERHERO", Class.forName("util.SuperHero"));
        rs.setTypeMap(map);
        assertTrue(rs.getTypeMap().equals(map));
    }

    /*
     * Validate that getUsername() returns same value set by
     * setUsername()
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0023(RowSet rs) throws Exception {
        rs.setUsername(user);
        assertTrue(rs.getUsername().equals(user));
    }

    /*
     * Validate that getPassword() returns same password set by
     * setPassword()
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0024(RowSet rs) throws Exception {
        rs.setPassword(password);
        assertTrue(rs.getPassword().equals(password));
    }

    /*
     * Validate that getQueryTimeout() returns same value set by
     * setQueryTimeout() and that 0 is a valid timeout value
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0025(RowSet rs) throws Exception {
        int timeout = 0;
        rs.setQueryTimeout(timeout);
        assertTrue(rs.getQueryTimeout() == timeout);
    }

    /*
     * Validate that getQueryTimeout() returns same value set by
     * setQueryTimeout() and that 0 is a valid timeout value
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0026(RowSet rs) throws Exception {
        int timeout = 10000;
        rs.setQueryTimeout(timeout);
        assertTrue(rs.getQueryTimeout() == timeout);
    }

    /*
     * Validate that setQueryTimeout() throws a SQLException for a timeout
     * value < 0
     */
    @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class)
    public void commonRowSetTest0027(RowSet rs) throws Exception {
        rs.setQueryTimeout(-1);
    }


    /*
     * Validate addRowSetListener does not throw an Exception when null is
     * passed as the parameter
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0028(RowSet rs) throws Exception {
        rs.addRowSetListener(null);
    }

    /*
     * Validate removeRowSetListener does not throw an Exception when null is
     * passed as the parameter
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0029(RowSet rs) throws Exception {
        rs.removeRowSetListener(null);
    }

    /*
     * Set two parameters and then validate clearParameters() will clear them
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0030(BaseRowSet rs) throws Exception {
        rs.setInt(1, 1);
        rs.setString(2, query);
        assertTrue(rs.getParams().length == 2);
        rs.clearParameters();
        assertTrue(rs.getParams().length == 0);
    }

    /*
     * Validate that getURL() returns same value set by
     * setURL()
     */
    @Test(dataProvider = "rowSetType")
    public void commonRowSetTest0031(RowSet rs) throws Exception {
        rs.setUrl(url);
        assertTrue(rs.getUrl().equals(url));
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0100(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setAsciiStream(1, is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0101(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setAsciiStream("one", is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0102(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setAsciiStream("one", is, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0103(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBinaryStream(1, is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0104(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBinaryStream("one", is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0105(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBinaryStream("one", is, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0106(RowSet rs) throws Exception {
        rs.setBigDecimal("one", BigDecimal.ONE);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0107(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBlob(1, is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0108(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBlob("one", is);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0109(RowSet rs) throws Exception {
        InputStream is = null;
        rs.setBlob("one", is, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0110(RowSet rs) throws Exception {
        rs.setBlob("one", new StubBlob());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0111(RowSet rs) throws Exception {
        rs.setBoolean("one", true);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0112(RowSet rs) throws Exception {
        byte b = 1;
        rs.setByte("one", b);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0113(RowSet rs) throws Exception {
        byte b = 1;
        rs.setBytes("one", new byte[10]);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0114(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setCharacterStream("one", rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0115(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setCharacterStream("one", rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0116(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setCharacterStream(1, rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0117(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setClob(1, rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0118(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setClob("one", rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0119(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setClob("one", rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0120(RowSet rs) throws Exception {
        rs.setClob("one", new StubClob());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0121(RowSet rs) throws Exception {
        rs.setDate("one", Date.valueOf(LocalDate.now()));
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0122(RowSet rs) throws Exception {
        rs.setDate("one", Date.valueOf(LocalDate.now()),
                Calendar.getInstance());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0123(RowSet rs) throws Exception {
        rs.setTime("one", Time.valueOf(LocalTime.now()));
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0124(RowSet rs) throws Exception {
        rs.setTime("one", Time.valueOf(LocalTime.now()),
                Calendar.getInstance());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0125(RowSet rs) throws Exception {
        rs.setTimestamp("one", Timestamp.valueOf(LocalDateTime.now()));
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0126(RowSet rs) throws Exception {
        rs.setTimestamp("one", Timestamp.valueOf(LocalDateTime.now()),
                Calendar.getInstance());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0127(RowSet rs) throws Exception {
        rs.setDouble("one", 2.0d);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0128(RowSet rs) throws Exception {
        rs.setFloat("one", 2.0f);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0129(RowSet rs) throws Exception {
        rs.setInt("one", 21);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0130(RowSet rs) throws Exception {
        rs.setLong("one", 21l);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0131(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNCharacterStream("one", rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0132(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNCharacterStream("one", rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0133(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNCharacterStream(1, rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0134(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNCharacterStream(1, rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0135(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setClob("one", rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0136(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setClob("one", rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0137(RowSet rs) throws Exception {
        rs.setNClob("one", new StubNClob());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0138(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNClob(1, rdr);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0139(RowSet rs) throws Exception {
        Reader rdr = null;
        rs.setNClob(1, rdr, query.length());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0140(RowSet rs) throws Exception {
        rs.setNClob(1, new StubNClob());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0141(RowSet rs) throws Exception {
        rs.setNString(1, query);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0142(RowSet rs) throws Exception {
        rs.setNull("one", Types.INTEGER);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0143(RowSet rs) throws Exception {
        rs.setNull("one", Types.INTEGER, "my.type");
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0144(RowSet rs) throws Exception {
        rs.setObject("one", query, Types.VARCHAR);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0145(RowSet rs) throws Exception {
        rs.setObject("one", query, Types.VARCHAR, 0);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0146(RowSet rs) throws Exception {
        rs.setObject("one", query);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0147(RowSet rs) throws Exception {
        RowId aRowid = null;
        rs.setRowId("one", aRowid);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0148(RowSet rs) throws Exception {
        rs.setSQLXML("one", new StubSQLXML());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0149(RowSet rs) throws Exception {
        rs.setSQLXML(1, new StubSQLXML());
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0150(RowSet rs) throws Exception {
        rs.setNString(1, query);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0151(RowSet rs) throws Exception {
        rs.setNString("one", query);
    }

    /*
     * This method is currently not implemented in BaseRowSet and will
     * throw a SQLFeatureNotSupportedException
     */
    @Test(dataProvider = "rowSetType",
            expectedExceptions = SQLFeatureNotSupportedException.class)
    public void commonRowSetTest0152(RowSet rs) throws Exception {
        short val = 21;
        rs.setShort("one", val);
    }

}