/*
* 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);
}
}
