| /* |
| * 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.cachedrowset; |
| |
| import java.math.BigDecimal; |
| import java.sql.Array; |
| import java.sql.Date; |
| import java.sql.JDBCType; |
| import java.sql.Ref; |
| import java.sql.ResultSet; |
| import java.sql.ResultSetMetaData; |
| import java.sql.SQLException; |
| 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.Collection; |
| import javax.sql.RowSet; |
| import javax.sql.rowset.CachedRowSet; |
| import javax.sql.rowset.RowSetMetaDataImpl; |
| import javax.sql.rowset.serial.SerialRef; |
| import javax.sql.rowset.spi.SyncFactory; |
| import javax.sql.rowset.spi.SyncProvider; |
| import javax.sql.rowset.spi.SyncProviderException; |
| import static org.testng.Assert.assertEquals; |
| import static org.testng.Assert.assertFalse; |
| import static org.testng.Assert.assertNull; |
| import static org.testng.Assert.assertTrue; |
| import org.testng.annotations.DataProvider; |
| import org.testng.annotations.Test; |
| import test.rowset.CommonRowSetTests; |
| import util.StubArray; |
| import util.StubRef; |
| import util.StubSyncProvider; |
| import util.TestRowSetListener; |
| |
| public abstract class CommonCachedRowSetTests extends CommonRowSetTests { |
| |
| /* |
| * DATATYPES Table column names |
| */ |
| private final String[] DATATYPES_COLUMN_NAMES = {"AINTEGER", "ACHAR", |
| "AVARCHAR", "ALONG", "ABOOLEAN", "ASHORT", "ADOUBLE", "ABIGDECIMAL", |
| "AREAL", "ABYTE", "ADATE", "ATIME", "ATIMESTAMP", "ABYTES", "ARRAY", |
| "AREF", "AFLOAT"}; |
| |
| /* |
| * Initializes a RowSet containing the DATAYPES data |
| */ |
| protected <T extends RowSet> T createDataTypesRowSet() throws SQLException { |
| T rs = (T) newInstance(); |
| initDataTypesMetaData((CachedRowSet) rs); |
| createDataTypesRows(rs); |
| // Make sure you are not on the insertRow |
| rs.moveToCurrentRow(); |
| return rs; |
| } |
| |
| //DataProviders to use for common tests |
| |
| /* |
| * DataProvider that uses a RowSet with the COFFEE_HOUSES Table |
| */ |
| @DataProvider(name = "rowsetUsingCoffeeHouses") |
| protected Object[][] rowsetUsingCoffeeHouses() throws Exception { |
| RowSet rs = createCoffeeHousesRowSet(); |
| return new Object[][]{ |
| {rs} |
| }; |
| } |
| |
| /* |
| * DataProvider that uses a RowSet with the COFFEES Table |
| */ |
| @DataProvider(name = "rowsetUsingCoffees") |
| protected Object[][] rowsetUsingCoffees() throws Exception { |
| RowSet rs = createCoffeesRowSet(); |
| return new Object[][]{ |
| {rs} |
| }; |
| } |
| |
| /* |
| * DataProvider that uses a RowSet with the DATAYPES Table and |
| * used to validate the various supported data types |
| */ |
| @DataProvider(name = "rowsetUsingDataTypes") |
| protected Object[][] rowsetUsingDataTypes() throws Exception { |
| |
| CachedRowSet rs = createDataTypesRowSet(); |
| return new Object[][]{ |
| {rs, JDBCType.INTEGER}, |
| {rs, JDBCType.CHAR}, |
| {rs, JDBCType.VARCHAR}, |
| {rs, JDBCType.BIGINT}, |
| {rs, JDBCType.BOOLEAN}, |
| {rs, JDBCType.SMALLINT}, |
| {rs, JDBCType.DOUBLE}, |
| {rs, JDBCType.DECIMAL}, |
| {rs, JDBCType.REAL}, |
| {rs, JDBCType.TINYINT}, |
| {rs, JDBCType.DATE}, |
| {rs, JDBCType.TIME}, |
| {rs, JDBCType.TIMESTAMP}, |
| {rs, JDBCType.VARBINARY}, |
| {rs, JDBCType.ARRAY}, |
| {rs, JDBCType.REF}, |
| {rs, JDBCType.FLOAT} |
| }; |
| } |
| |
| /* |
| * Initializes the DATAYPES table metadata |
| */ |
| protected void initDataTypesMetaData(CachedRowSet crs) throws SQLException { |
| RowSetMetaDataImpl rsmd = new RowSetMetaDataImpl(); |
| crs.setType(RowSet.TYPE_SCROLL_INSENSITIVE); |
| |
| rsmd.setColumnCount(DATATYPES_COLUMN_NAMES.length); |
| |
| for (int i = 1; i <= DATATYPES_COLUMN_NAMES.length; i++) { |
| rsmd.setColumnName(i, DATATYPES_COLUMN_NAMES[i - 1]); |
| rsmd.setColumnLabel(i, rsmd.getColumnName(i)); |
| } |
| |
| rsmd.setColumnType(1, Types.INTEGER); |
| rsmd.setColumnType(2, Types.CHAR); |
| rsmd.setColumnType(3, Types.VARCHAR); |
| rsmd.setColumnType(4, Types.BIGINT); |
| rsmd.setColumnType(5, Types.BOOLEAN); |
| rsmd.setColumnType(6, Types.SMALLINT); |
| rsmd.setColumnType(7, Types.DOUBLE); |
| rsmd.setColumnType(8, Types.DECIMAL); |
| rsmd.setColumnType(9, Types.REAL); |
| rsmd.setColumnType(10, Types.TINYINT); |
| rsmd.setColumnType(11, Types.DATE); |
| rsmd.setColumnType(12, Types.TIME); |
| rsmd.setColumnType(13, Types.TIMESTAMP); |
| rsmd.setColumnType(14, Types.VARBINARY); |
| rsmd.setColumnType(15, Types.ARRAY); |
| rsmd.setColumnType(16, Types.REF); |
| rsmd.setColumnType(17, Types.FLOAT); |
| crs.setMetaData(rsmd); |
| |
| } |
| |
| /* |
| * Add rows to DATAYPES table |
| */ |
| protected void createDataTypesRows(RowSet crs) throws SQLException { |
| |
| Integer aInteger = 100; |
| String aChar = "Oswald Cobblepot"; |
| Long aLong = Long.MAX_VALUE; |
| Short aShort = Short.MAX_VALUE; |
| Double aDouble = Double.MAX_VALUE; |
| BigDecimal aBigDecimal = BigDecimal.ONE; |
| Boolean aBoolean = false; |
| Float aFloat = Float.MAX_VALUE; |
| Byte aByte = Byte.MAX_VALUE; |
| Date aDate = Date.valueOf(LocalDate.now()); |
| Time aTime = Time.valueOf(LocalTime.now()); |
| Timestamp aTimeStamp = Timestamp.valueOf(LocalDateTime.now()); |
| Array aArray = new StubArray("INTEGER", new Object[1]); |
| Ref aRef = new SerialRef(new StubRef("INTEGER", query)); |
| byte[] bytes = new byte[10]; |
| crs.moveToInsertRow(); |
| crs.updateInt(1, aInteger); |
| crs.updateString(2, aChar); |
| crs.updateString(3, aChar); |
| crs.updateLong(4, aLong); |
| crs.updateBoolean(5, aBoolean); |
| crs.updateShort(6, aShort); |
| crs.updateDouble(7, aDouble); |
| crs.updateBigDecimal(8, aBigDecimal); |
| crs.updateFloat(9, aFloat); |
| crs.updateByte(10, aByte); |
| crs.updateDate(11, aDate); |
| crs.updateTime(12, aTime); |
| crs.updateTimestamp(13, aTimeStamp); |
| crs.updateBytes(14, bytes); |
| crs.updateArray(15, aArray); |
| crs.updateRef(16, aRef); |
| crs.updateDouble(17, aDouble); |
| crs.insertRow(); |
| crs.moveToCurrentRow(); |
| |
| } |
| |
| /* |
| * Dermine if a Row exists in a ResultSet by its primary key |
| * If the parameter deleteRow is true, delete the row and validate |
| * the RowSet indicates it is deleted |
| */ |
| protected boolean findRowByPrimaryKey(RowSet rs, int id, int idPos, |
| boolean deleteRow) throws Exception { |
| boolean foundRow = false; |
| rs.beforeFirst(); |
| while (rs.next()) { |
| if (rs.getInt(idPos) == id) { |
| foundRow = true; |
| if (deleteRow) { |
| rs.deleteRow(); |
| // validate row is marked as deleted |
| assertTrue(rs.rowDeleted()); |
| } |
| break; |
| } |
| } |
| return foundRow; |
| } |
| |
| /* |
| * Wrapper method to find if a row exists within a RowSet by its primary key |
| */ |
| protected boolean findRowByPrimaryKey(RowSet rs, int id, int idPos) throws Exception { |
| return findRowByPrimaryKey(rs, id, idPos, false); |
| } |
| |
| /* |
| * Wrapper method to find if a row exists within a RowSet by its primary key |
| * and delete it |
| */ |
| protected boolean deleteRowByPrimaryKey(RowSet rs, int id, int idPos) throws Exception { |
| return findRowByPrimaryKey(rs, id, idPos, true); |
| } |
| |
| /* |
| * Utility method that compares two ResultSetMetaDataImpls for containing |
| * the same values |
| */ |
| private void compareMetaData(ResultSetMetaData rsmd, |
| ResultSetMetaData rsmd1) throws SQLException { |
| |
| assertEquals(rsmd1.getColumnCount(), rsmd.getColumnCount()); |
| int cols = rsmd.getColumnCount(); |
| for (int i = 1; i <= cols; i++) { |
| assertTrue(rsmd1.getCatalogName(i).equals(rsmd.getCatalogName(i))); |
| assertTrue(rsmd1.getColumnClassName(i).equals(rsmd.getColumnClassName(i))); |
| assertTrue(rsmd1.getColumnDisplaySize(i) == rsmd.getColumnDisplaySize(i)); |
| assertTrue(rsmd1.getColumnLabel(i).equals(rsmd.getColumnLabel(i))); |
| assertTrue(rsmd1.getColumnName(i).equals(rsmd.getColumnName(i))); |
| assertTrue(rsmd1.getColumnType(i) == rsmd.getColumnType(i)); |
| assertTrue(rsmd1.getPrecision(i) == rsmd.getPrecision(i)); |
| assertTrue(rsmd1.getScale(i) == rsmd.getScale(i)); |
| assertTrue(rsmd1.getSchemaName(i).equals(rsmd.getSchemaName(i))); |
| assertTrue(rsmd1.getTableName(i).equals(rsmd.getTableName(i))); |
| assertTrue(rsmd1.isAutoIncrement(i) == rsmd.isAutoIncrement(i)); |
| assertTrue(rsmd1.isCaseSensitive(i) == rsmd.isCaseSensitive(i)); |
| assertTrue(rsmd1.isCurrency(i) == rsmd.isCurrency(i)); |
| assertTrue(rsmd1.isDefinitelyWritable(i) == rsmd.isDefinitelyWritable(i)); |
| assertTrue(rsmd1.isNullable(i) == rsmd.isNullable(i)); |
| assertTrue(rsmd1.isReadOnly(i) == rsmd.isReadOnly(i)); |
| assertTrue(rsmd1.isSearchable(i) == rsmd.isSearchable(i)); |
| assertTrue(rsmd1.isSigned(i) == rsmd.isSigned(i)); |
| assertTrue(rsmd1.isWritable(i) == rsmd.isWritable(i)); |
| |
| } |
| } |
| |
| /* |
| * Utility method to compare two rowsets |
| */ |
| private void compareRowSets(CachedRowSet crs, CachedRowSet crs1) throws Exception { |
| |
| int rows = crs.size(); |
| assertTrue(rows == crs1.size()); |
| |
| ResultSetMetaData rsmd = crs.getMetaData(); |
| |
| compareMetaData(rsmd, crs1.getMetaData()); |
| int cols = rsmd.getColumnCount(); |
| |
| for (int row = 1; row <= rows; row++) { |
| crs.absolute((row)); |
| crs1.absolute(row); |
| for (int col = 1; col <= cols; col++) { |
| compareColumnValue(JDBCType.valueOf(rsmd.getColumnType(col)), |
| crs, crs1, col); |
| } |
| } |
| |
| } |
| |
| /* |
| * Utility method to compare two columns |
| */ |
| private void compareColumnValue(JDBCType type, ResultSet rs, ResultSet rs1, |
| int col) throws SQLException { |
| |
| switch (type) { |
| case INTEGER: |
| assertTrue(rs.getInt(col) == rs1.getInt(col)); |
| break; |
| case CHAR: |
| case VARCHAR: |
| assertTrue(rs.getString(col).equals(rs1.getString(col))); |
| break; |
| case BIGINT: |
| assertTrue(rs.getLong(col) == rs1.getLong(col)); |
| break; |
| case BOOLEAN: |
| assertTrue(rs.getBoolean(col) == rs1.getBoolean(col)); |
| break; |
| case SMALLINT: |
| assertTrue(rs.getShort(col) == rs1.getShort(col)); |
| break; |
| case DOUBLE: |
| case FLOAT: |
| assertTrue(rs.getDouble(col) == rs1.getDouble(col)); |
| break; |
| case DECIMAL: |
| assertTrue(rs.getBigDecimal(col).equals(rs1.getBigDecimal(col))); |
| break; |
| case REAL: |
| assertTrue(rs.getFloat(col) == rs1.getFloat(col)); |
| break; |
| case TINYINT: |
| assertTrue(rs.getByte(col) == rs1.getByte(col)); |
| break; |
| case DATE: |
| assertTrue(rs.getDate(col).equals(rs1.getDate(col))); |
| break; |
| case TIME: |
| assertTrue(rs.getTime(col).equals(rs1.getTime(col))); |
| break; |
| case TIMESTAMP: |
| assertTrue(rs.getTimestamp(col).equals(rs1.getTimestamp(col))); |
| break; |
| } |
| } |
| |
| /* |
| * Validate SyncProviderException is thrown when acceptChanges is called |
| * but there is not a way to make a connection to the datasource |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SyncProviderException.class) |
| public void commonCachedRowSetTest0000(CachedRowSet rs) throws Exception { |
| rs.acceptChanges(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate SyncProviderException is thrown when acceptChanges is called |
| * when null is passed as the datasource |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SyncProviderException.class) |
| public void commonCachedRowSetTest0001(CachedRowSet rs) throws Exception { |
| rs.acceptChanges(null); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that that RIOPtimsticProvider is the default SyncProvider |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0002(CachedRowSet rs) throws SQLException { |
| SyncProvider sp = rs.getSyncProvider(); |
| assertTrue(sp instanceof com.sun.rowset.providers.RIOptimisticProvider); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that you can specify a SyncProvider |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0003(CachedRowSet rs) throws SQLException { |
| |
| // Register a provider and make sure it is avaiable |
| SyncFactory.registerProvider(stubProvider); |
| rs.setSyncProvider(stubProvider); |
| SyncProvider sp = rs.getSyncProvider(); |
| assertTrue(sp instanceof StubSyncProvider); |
| SyncFactory.unregisterProvider(stubProvider); |
| rs.close(); |
| } |
| |
| /* |
| * Create a RowSetListener and validate that notifyRowSetChanged is called |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0004(CachedRowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| rs.release(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED)); |
| rs.close(); |
| } |
| |
| /* |
| * Create a RowSetListener and validate that notifyRowSetChanged is called |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0005(CachedRowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| rs.restoreOriginal(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED)); |
| rs.close(); |
| } |
| |
| /* |
| * Create a RowSetListener and validate that notifyRowChanged is called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0006(RowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| rs.moveToInsertRow(); |
| rs.updateInt(1, 10024); |
| rs.updateString(2, "Sacramento"); |
| rs.updateInt(3, 1987); |
| rs.updateInt(4, 2341); |
| rs.updateInt(5, 4328); |
| rs.insertRow(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED)); |
| rs.close(); |
| } |
| |
| /* |
| * Create a multiple RowSetListeners and validate that notifyRowChanged, |
| * notifiyMoved is called on all listners |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0007(RowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| TestRowSetListener rsl2 = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| rs.addRowSetListener(rsl2); |
| rs.first(); |
| rs.updateInt(1, 1961); |
| rs.updateString(2, "Pittsburgh"); |
| rs.updateInt(3, 1987); |
| rs.updateInt(4, 2341); |
| rs.updateInt(5, 6689); |
| rs.updateRow(); |
| assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED |
| | TestRowSetListener.ROW_CHANGED)); |
| assertTrue(rsl2.isNotified(TestRowSetListener.CURSOR_MOVED |
| | TestRowSetListener.ROW_CHANGED)); |
| rs.close(); |
| } |
| |
| /* |
| * Create a RowSetListener and validate that notifyRowChanged and |
| * notifyCursorMoved are called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0008(CachedRowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| |
| rs.first(); |
| assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED)); |
| rs.deleteRow(); |
| assertTrue( |
| rsl.isNotified(TestRowSetListener.ROW_CHANGED | TestRowSetListener.CURSOR_MOVED)); |
| rsl.resetFlag(); |
| rs.setShowDeleted(true); |
| rs.undoDelete(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED)); |
| rs.close(); |
| } |
| |
| /* |
| * Create a RowSetListener and validate that notifyCursorMoved is called |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0009(RowSet rs) throws Exception { |
| TestRowSetListener rsl = new TestRowSetListener(); |
| rs.addRowSetListener(rsl); |
| rs.beforeFirst(); |
| assertTrue(rsl.isNotified(TestRowSetListener.CURSOR_MOVED)); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getTableName() returns the proper values |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0010(CachedRowSet rs) throws Exception { |
| assertNull(rs.getTableName()); |
| rs.setTableName(COFFEE_HOUSES_TABLE); |
| assertTrue(rs.getTableName().equals(COFFEE_HOUSES_TABLE)); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getKeyColumns() returns the proper values |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0011(CachedRowSet rs) throws Exception { |
| int[] pkeys = {1, 3}; |
| assertNull(rs.getKeyColumns()); |
| rs.setKeyColumns(pkeys); |
| assertEquals(rs.getKeyColumns(), pkeys); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that setMatchColumn throws a SQLException if the column |
| * index specified is out of range |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0012(CachedRowSet rs) throws Exception { |
| rs.setMatchColumn(-1); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that setMatchColumn throws a SQLException if the column |
| * index specified is out of range |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0013(CachedRowSet rs) throws Exception { |
| int[] cols = {1, -1}; |
| rs.setMatchColumn(cols); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that setMatchColumn throws a SQLException if the column |
| * index specified is out of range |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0014(CachedRowSet rs) throws Exception { |
| rs.setMatchColumn((String) null); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that setMatchColumn throws a SQLException if the column |
| * index specified is out of range |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0015(CachedRowSet rs) throws Exception { |
| String[] cols = {"ID", null}; |
| rs.setMatchColumn(cols); |
| } |
| |
| /* |
| * Validate that getMatchColumn returns the same value specified by |
| * setMatchColumn |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false) |
| public void commonCachedRowSetTest0016(CachedRowSet rs) throws Exception { |
| int[] expectedCols = {1}; |
| String[] expectedColNames = {"ID"}; |
| rs.setMatchColumn(1); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| for (int i = 0; i < actualCols.length; i++) { |
| System.out.println(actualCols[i]); |
| } |
| assertEquals(actualCols, expectedCols); |
| assertEquals(actualColNames, expectedColNames); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumn returns the same value specified by |
| * setMatchColumn |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false) |
| public void commonCachedRowSetTest0017(CachedRowSet rs) throws Exception { |
| int[] expectedCols = {1}; |
| String[] expectedColNames = {"ID"}; |
| rs.setMatchColumn(expectedColNames[0]); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| assertEquals(actualCols, expectedCols); |
| assertEquals(actualColNames, expectedColNames); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumn returns the same valid value specified by |
| * setMatchColumn |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false) |
| public void commonCachedRowSetTest0018(CachedRowSet rs) throws Exception { |
| int[] expectedCols = {1, 3}; |
| String[] expectedColNames = {"COF_ID", "SUP_ID"}; |
| rs.setMatchColumn(expectedCols); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| assertEquals(actualCols, expectedCols); |
| assertEquals(actualColNames, expectedColNames); |
| assertEquals(actualCols, expectedCols); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumn returns the same valid value specified by |
| * setMatchColumn |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", enabled = false) |
| public void commonCachedRowSetTest0019(CachedRowSet rs) throws Exception { |
| int[] expectedCols = {1, 3}; |
| String[] expectedColNames = {"COF_ID", "SUP_ID"}; |
| rs.setMatchColumn(expectedColNames); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| assertEquals(actualCols, expectedCols); |
| assertEquals(actualColNames, expectedColNames); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumnIndexes throws a SQLException if |
| * unsetMatchColumn has been called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0020(CachedRowSet rs) throws Exception { |
| rs.setMatchColumn(1); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| assertTrue(actualCols != null); |
| rs.unsetMatchColumn(1); |
| actualCols = rs.getMatchColumnIndexes(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumnNames throws a SQLException if |
| * unsetMatchColumn has been called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0021(CachedRowSet rs) throws Exception { |
| String matchColumn = "ID"; |
| rs.setMatchColumn(matchColumn); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| assertTrue(actualColNames != null); |
| rs.unsetMatchColumn(matchColumn); |
| actualColNames = rs.getMatchColumnNames(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumnIndexes throws a SQLException if |
| * unsetMatchColumn has been called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0022(CachedRowSet rs) throws Exception { |
| int[] expectedCols = {1, 3}; |
| rs.setMatchColumn(expectedCols); |
| int[] actualCols = rs.getMatchColumnIndexes(); |
| assertTrue(actualCols != null); |
| rs.unsetMatchColumn(expectedCols); |
| actualCols = rs.getMatchColumnIndexes(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that getMatchColumnNames throws a SQLException if |
| * unsetMatchColumn has been called |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0023(CachedRowSet rs) throws Exception { |
| String[] expectedColNames = {"COF_ID", "SUP_ID"}; |
| rs.setMatchColumn(expectedColNames); |
| String[] actualColNames = rs.getMatchColumnNames(); |
| assertTrue(actualColNames != null); |
| rs.unsetMatchColumn(expectedColNames); |
| actualColNames = rs.getMatchColumnNames(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate size() returns the correct number of rows |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0024(CachedRowSet rs) throws Exception { |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that the correct rows are returned comparing the primary |
| * keys |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0025(RowSet rs) throws SQLException { |
| assertEquals(getPrimaryKeys(rs), COFFEE_HOUSES_PRIMARY_KEYS); |
| rs.close(); |
| } |
| |
| /* |
| * Delete a row within the RowSet using its primary key |
| * Validate the visibility of the row depending on the value of |
| * setShowdelete |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0026(CachedRowSet rs) throws Exception { |
| Object[] afterDelete = { |
| 10023, 33002, 10040, 32001, 10042, 10024, 10039, 10041, |
| 33005, 33010, 10037, 10034, 32004 |
| }; |
| int rowToDelete = 10035; |
| // All rows should be found |
| assertEquals(getPrimaryKeys(rs), COFFEE_HOUSES_PRIMARY_KEYS); |
| // Delete the row |
| assertTrue(deleteRowByPrimaryKey(rs, rowToDelete, 1)); |
| // With setShowDeleted(false) which is the default, |
| // the deleted row should not be visible |
| assertFalse(findRowByPrimaryKey(rs, rowToDelete, 1)); |
| assertEquals(getPrimaryKeys(rs), afterDelete); |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| // With setShowDeleted(true), the deleted row should be visible |
| rs.setShowDeleted(true); |
| assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1)); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that there is no page size by default |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0027(CachedRowSet rs) throws Exception { |
| assertTrue(rs.getPageSize() == 0); |
| rs.close(); |
| } |
| |
| /* |
| * Validate the value you set via setPageSize is returned by getPageSize |
| * then reset to having no limit |
| */ |
| @Test(dataProvider = "rowSetType") |
| public void commonCachedRowSetTest0028(CachedRowSet rs) throws Exception { |
| int rows = 100; |
| rs.setPageSize(rows); |
| assertTrue(rows == rs.getPageSize()); |
| rs.setPageSize(0); |
| assertTrue(rs.getPageSize() == 0); |
| rs.close(); |
| } |
| |
| /* |
| * Validate SQLException is thrown when an invalid value is specified |
| * for setPageSize |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0029(CachedRowSet rs) throws Exception { |
| rs.setPageSize(-1); |
| rs.close(); |
| } |
| |
| /* |
| * Validate SQLException is thrown when nextPage is called without a |
| * call to populate or execute |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0030(CachedRowSet rs) throws Exception { |
| rs.nextPage(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate SQLException is thrown when previousPage is called without a |
| * call to populate or execute |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0031(CachedRowSet rs) throws Exception { |
| rs.previousPage(); |
| rs.close(); |
| } |
| |
| |
| /* |
| * Validate SQLException is thrown when execute is called |
| * but there is not a way to make a connection to the datasource |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0032(CachedRowSet rs) throws Exception { |
| rs.execute(null); |
| rs.close(); |
| } |
| |
| /* |
| * Validate SQLException is thrown when execute is called |
| * but there is not a way to make a connection to the datasource |
| */ |
| @Test(dataProvider = "rowSetType", expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0033(CachedRowSet rs) throws Exception { |
| rs.execute(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that toCollection(<column>) returns the proper values |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0034(CachedRowSet rs) throws Exception { |
| Object[] cities = {"Mendocino", "Seattle", "SF", "Portland", "SF", |
| "Sacramento", "Carmel", "LA", "Olympia", "Seattle", "SF", |
| "LA", "San Jose", "Eugene"}; |
| rs.beforeFirst(); |
| assertEquals(rs.toCollection(2).toArray(), cities); |
| assertEquals(rs.toCollection("CITY").toArray(), cities); |
| rs.close(); |
| } |
| |
| /* |
| * Validate that toCollection() returns the proper values |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0035(CachedRowSet rs) throws Exception { |
| Collection<?> col = rs.toCollection(); |
| assertTrue(rs.size() == col.size()); |
| assertTrue(rs.toCollection().containsAll(col) |
| && col.containsAll(rs.toCollection())); |
| try ( // Validate that False is returned when compared to a different RowSet; |
| CachedRowSet crs1 = createCoffeesRowSet()) { |
| assertFalse(crs1.toCollection().containsAll(col) |
| && col.containsAll(crs1.toCollection())); |
| } |
| rs.close(); |
| |
| } |
| |
| /* |
| * Validate that createCopy() returns the proper values |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0036(CachedRowSet rs) throws Exception { |
| try (CachedRowSet crs1 = rs.createCopy()) { |
| compareRowSets(rs, crs1); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that createCopySchema() returns the proper values |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0037(CachedRowSet rs) throws Exception { |
| try (CachedRowSet crs1 = rs.createCopySchema()) { |
| assertTrue(crs1.size() == 0); |
| compareMetaData(crs1.getMetaData(), rs.getMetaData()); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that createCopyNoConstraints() returns the proper values |
| * and getMatchColumnIndexes should throw a SQLException. This test |
| * specifies setMatchColumn(int) |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0038(CachedRowSet rs) throws Exception { |
| rs.setMatchColumn(1); |
| try (CachedRowSet crs1 = rs.createCopyNoConstraints()) { |
| assertTrue(crs1.size() == COFFEE_HOUSES_ROWS); |
| compareRowSets(rs, crs1); |
| boolean recievedSQE = false; |
| try { |
| int[] indexes = crs1.getMatchColumnIndexes(); |
| } catch (SQLException e) { |
| recievedSQE = true; |
| } |
| assertTrue(recievedSQE); |
| recievedSQE = false; |
| try { |
| String[] colNames = crs1.getMatchColumnNames(); |
| } catch (SQLException e) { |
| recievedSQE = true; |
| } |
| assertTrue(recievedSQE); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that createCopyNoConstraints() returns the proper values |
| * and getMatchColumnIndexes should throw a SQLException. This test |
| * specifies setMatchColumn(String) |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0039(CachedRowSet rs) throws Exception { |
| rs.setMatchColumn("ID"); |
| try (CachedRowSet crs1 = rs.createCopyNoConstraints()) { |
| assertTrue(crs1.size() == COFFEE_HOUSES_ROWS); |
| compareRowSets(rs, crs1); |
| boolean recievedSQE = false; |
| try { |
| int[] indexes = crs1.getMatchColumnIndexes(); |
| } catch (SQLException e) { |
| recievedSQE = true; |
| } |
| assertTrue(recievedSQE); |
| recievedSQE = false; |
| try { |
| String[] colNames = crs1.getMatchColumnNames(); |
| } catch (SQLException e) { |
| recievedSQE = true; |
| } |
| assertTrue(recievedSQE); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that columnUpdated works with the various datatypes specifying |
| * the column index |
| */ |
| @Test(dataProvider = "rowsetUsingDataTypes") |
| public void commonCachedRowSetTest0040(CachedRowSet rs, JDBCType type) throws Exception { |
| rs.beforeFirst(); |
| assertTrue(rs.next()); |
| switch (type) { |
| case INTEGER: |
| assertFalse(rs.columnUpdated(1)); |
| rs.updateInt(1, Integer.MIN_VALUE); |
| assertTrue(rs.columnUpdated(1)); |
| break; |
| case CHAR: |
| assertFalse(rs.columnUpdated(2)); |
| rs.updateString(2, "foo"); |
| assertTrue(rs.columnUpdated(2)); |
| break; |
| case VARCHAR: |
| assertFalse(rs.columnUpdated(3)); |
| rs.updateString(3, "foo"); |
| assertTrue(rs.columnUpdated(3)); |
| break; |
| case BIGINT: |
| assertFalse(rs.columnUpdated(4)); |
| rs.updateLong(4, Long.MIN_VALUE); |
| assertTrue(rs.columnUpdated(4)); |
| break; |
| case BOOLEAN: |
| assertFalse(rs.columnUpdated(5)); |
| rs.updateBoolean(5, false); |
| assertTrue(rs.columnUpdated(5)); |
| break; |
| case SMALLINT: |
| assertFalse(rs.columnUpdated(6)); |
| rs.updateShort(6, Short.MIN_VALUE); |
| assertTrue(rs.columnUpdated(6)); |
| break; |
| case DOUBLE: |
| assertFalse(rs.columnUpdated(7)); |
| rs.updateDouble(7, Double.MIN_VALUE); |
| assertTrue(rs.columnUpdated(7)); |
| break; |
| case DECIMAL: |
| assertFalse(rs.columnUpdated(8)); |
| rs.updateBigDecimal(8, BigDecimal.TEN); |
| assertTrue(rs.columnUpdated(8)); |
| break; |
| case REAL: |
| assertFalse(rs.columnUpdated(9)); |
| rs.updateFloat(9, Float.MIN_VALUE); |
| assertTrue(rs.columnUpdated(9)); |
| break; |
| case TINYINT: |
| assertFalse(rs.columnUpdated(10)); |
| rs.updateByte(10, Byte.MIN_VALUE); |
| assertTrue(rs.columnUpdated(10)); |
| break; |
| case DATE: |
| assertFalse(rs.columnUpdated(11)); |
| rs.updateDate(11, Date.valueOf(LocalDate.now())); |
| assertTrue(rs.columnUpdated(11)); |
| break; |
| case TIME: |
| assertFalse(rs.columnUpdated(12)); |
| rs.updateTime(12, Time.valueOf(LocalTime.now())); |
| assertTrue(rs.columnUpdated(12)); |
| break; |
| case TIMESTAMP: |
| assertFalse(rs.columnUpdated(13)); |
| rs.updateTimestamp(13, Timestamp.valueOf(LocalDateTime.now())); |
| assertTrue(rs.columnUpdated(13)); |
| break; |
| case VARBINARY: |
| assertFalse(rs.columnUpdated(14)); |
| rs.updateBytes(14, new byte[1]); |
| assertTrue(rs.columnUpdated(14)); |
| break; |
| case ARRAY: |
| assertFalse(rs.columnUpdated(15)); |
| rs.updateArray(15, new StubArray("VARCHAR", new Object[10])); |
| assertTrue(rs.columnUpdated(15)); |
| break; |
| case REF: |
| assertFalse(rs.columnUpdated(16)); |
| rs.updateRef(16, new StubRef("INTEGER", query)); |
| assertTrue(rs.columnUpdated(16)); |
| break; |
| case FLOAT: |
| assertFalse(rs.columnUpdated(17)); |
| rs.updateDouble(17, Double.MIN_NORMAL); |
| assertTrue(rs.columnUpdated(17)); |
| } |
| |
| } |
| |
| /* |
| * Validate that columnUpdated works with the various datatypes specifying |
| * the column name |
| */ |
| @Test(dataProvider = "rowsetUsingDataTypes") |
| public void commonCachedRowSetTest0041(CachedRowSet rs, JDBCType type) throws Exception { |
| rs.beforeFirst(); |
| assertTrue(rs.next()); |
| switch (type) { |
| case INTEGER: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[0])); |
| rs.updateInt(DATATYPES_COLUMN_NAMES[0], Integer.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[0])); |
| break; |
| case CHAR: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[1])); |
| rs.updateString(DATATYPES_COLUMN_NAMES[1], "foo"); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[1])); |
| break; |
| case VARCHAR: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[2])); |
| rs.updateString(DATATYPES_COLUMN_NAMES[2], "foo"); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[2])); |
| break; |
| case BIGINT: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[3])); |
| rs.updateLong(DATATYPES_COLUMN_NAMES[3], Long.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[3])); |
| break; |
| case BOOLEAN: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[4])); |
| rs.updateBoolean(DATATYPES_COLUMN_NAMES[4], false); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[4])); |
| break; |
| case SMALLINT: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[5])); |
| rs.updateShort(DATATYPES_COLUMN_NAMES[5], Short.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[5])); |
| break; |
| case DOUBLE: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[6])); |
| rs.updateDouble(DATATYPES_COLUMN_NAMES[6], Double.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[6])); |
| break; |
| case DECIMAL: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[7])); |
| rs.updateBigDecimal(DATATYPES_COLUMN_NAMES[7], BigDecimal.TEN); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[7])); |
| break; |
| case REAL: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[8])); |
| rs.updateFloat(DATATYPES_COLUMN_NAMES[8], Float.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[8])); |
| break; |
| case TINYINT: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[9])); |
| rs.updateByte(DATATYPES_COLUMN_NAMES[9], Byte.MIN_VALUE); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[9])); |
| break; |
| case DATE: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[10])); |
| rs.updateDate(DATATYPES_COLUMN_NAMES[10], Date.valueOf(LocalDate.now())); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[10])); |
| break; |
| case TIME: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[11])); |
| rs.updateTime(DATATYPES_COLUMN_NAMES[11], Time.valueOf(LocalTime.now())); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[11])); |
| break; |
| case TIMESTAMP: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[12])); |
| rs.updateTimestamp(DATATYPES_COLUMN_NAMES[12], Timestamp.valueOf(LocalDateTime.now())); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[12])); |
| break; |
| case VARBINARY: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[13])); |
| rs.updateBytes(DATATYPES_COLUMN_NAMES[13], new byte[1]); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[13])); |
| break; |
| case ARRAY: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[14])); |
| rs.updateArray(DATATYPES_COLUMN_NAMES[14], new StubArray("VARCHAR", new Object[10])); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[14])); |
| break; |
| case REF: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[15])); |
| rs.updateRef(DATATYPES_COLUMN_NAMES[15], new StubRef("INTEGER", query)); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[15])); |
| break; |
| case FLOAT: |
| assertFalse(rs.columnUpdated(DATATYPES_COLUMN_NAMES[16])); |
| rs.updateDouble(DATATYPES_COLUMN_NAMES[16], Double.MIN_NORMAL); |
| assertTrue(rs.columnUpdated(DATATYPES_COLUMN_NAMES[16])); |
| break; |
| } |
| |
| } |
| |
| /* |
| * Validate isBeforeFirst(), isFirst() and first() return the correct |
| * results |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0042(RowSet rs) throws Exception { |
| assertFalse(rs.isBeforeFirst()); |
| assertFalse(rs.isFirst()); |
| rs.beforeFirst(); |
| assertTrue(rs.isBeforeFirst()); |
| assertFalse(rs.isFirst()); |
| rs.next(); |
| assertFalse(rs.isBeforeFirst()); |
| assertTrue(rs.isFirst()); |
| rs.next(); |
| assertFalse(rs.isBeforeFirst()); |
| assertFalse(rs.isFirst()); |
| rs.first(); |
| assertFalse(rs.isBeforeFirst()); |
| assertTrue(rs.isFirst()); |
| rs.close(); |
| } |
| |
| /* |
| * Validate isAfterLast(), isLast() and last() return the correct |
| * results |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0043(RowSet rs) throws Exception { |
| assertFalse(rs.isAfterLast()); |
| assertFalse(rs.isLast()); |
| rs.afterLast(); |
| assertTrue(rs.isAfterLast()); |
| assertFalse(rs.isLast()); |
| rs.previous(); |
| assertFalse(rs.isAfterLast()); |
| assertTrue(rs.isLast()); |
| rs.previous(); |
| assertFalse(rs.isAfterLast()); |
| assertFalse(rs.isLast()); |
| rs.last(); |
| assertFalse(rs.isAfterLast()); |
| assertTrue(rs.isLast()); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoDelete is called on the |
| * insertRow |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0044(CachedRowSet rs) throws Exception { |
| rs.insertRow(); |
| rs.undoDelete(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoDelete is called when |
| * cursor is before the first row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0045(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.beforeFirst(); |
| rs.undoDelete(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoDelete is called when |
| * cursor is after the last row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0046(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.afterLast(); |
| rs.undoDelete(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoUpdate is called on the |
| * insertRow |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0047(CachedRowSet rs) throws Exception { |
| rs.insertRow(); |
| rs.undoUpdate(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoUpdate is called when |
| * cursor is before the first row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0048(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.beforeFirst(); |
| rs.undoUpdate(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoUpdate is called when |
| * cursor is after the last row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0049(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.afterLast(); |
| rs.undoUpdate(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoInsert is called on the |
| * insertRow |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0050(CachedRowSet rs) throws Exception { |
| rs.insertRow(); |
| rs.undoInsert(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoInsert is called when |
| * cursor is before the first row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0051(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.beforeFirst(); |
| rs.undoInsert(); |
| rs.close(); |
| } |
| |
| /* |
| * Validate a SQLException is thrown when undoInsert is called when |
| * cursor is after the last row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses", |
| expectedExceptions = SQLException.class) |
| public void commonCachedRowSetTest0052(CachedRowSet rs) throws Exception { |
| rs.setShowDeleted(true); |
| rs.afterLast(); |
| rs.undoInsert(); |
| rs.close(); |
| } |
| |
| /* |
| * Insert a row, then call undoInsert to roll back the insert and validate |
| * the row is not there |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0053(CachedRowSet rs) throws Exception { |
| int rowToInsert = 1961; |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| // Add new row |
| rs.moveToInsertRow(); |
| rs.updateInt(1, rowToInsert); |
| rs.updateString(2, "GOTHAM"); |
| rs.updateInt(3, 3450); |
| rs.updateInt(4, 2005); |
| rs.updateInt(5, 5455); |
| rs.insertRow(); |
| rs.moveToCurrentRow(); |
| // check that the number of rows has increased |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1); |
| assertTrue(findRowByPrimaryKey(rs, rowToInsert, 1)); |
| rs.undoInsert(); |
| // Check to make sure the row is no longer there |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| assertFalse(findRowByPrimaryKey(rs, rowToInsert, 1)); |
| rs.close(); |
| } |
| |
| /* |
| * Insert a row, delete the row and then call undoDelete to make sure it |
| * is comes back |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0054(CachedRowSet rs) throws Exception { |
| int rowToDelete = 1961; |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| // Add new row |
| rs.moveToInsertRow(); |
| rs.updateInt(1, rowToDelete); |
| rs.updateString(2, "GOTHAM"); |
| rs.updateInt(3, 3450); |
| rs.updateInt(4, 2005); |
| rs.updateInt(5, 5455); |
| rs.insertRow(); |
| rs.moveToCurrentRow(); |
| // check that the number of rows has increased |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1); |
| assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1)); |
| rs.absolute(COFFEE_HOUSES_ROWS + 1); |
| rs.deleteRow(); |
| // Check to make sure the row is no longer there |
| //assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| assertFalse(findRowByPrimaryKey(rs, rowToDelete, 1)); |
| rs.setShowDeleted(true); |
| rs.absolute(COFFEE_HOUSES_ROWS + 1); |
| rs.undoDelete(); |
| // check that the row is back |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1); |
| assertTrue(findRowByPrimaryKey(rs, rowToDelete, 1)); |
| rs.close(); |
| } |
| |
| /* |
| * Insert a row, modify a field and then call undoUpdate to revert the |
| * insert |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0055(CachedRowSet rs) throws Exception { |
| int rowToInsert = 1961; |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| // Add new row |
| rs.moveToInsertRow(); |
| rs.updateInt(1, rowToInsert); |
| rs.updateString(2, "GOTHAM"); |
| rs.updateInt(3, 3450); |
| rs.updateInt(4, 2005); |
| rs.updateInt(5, 5455); |
| rs.insertRow(); |
| rs.moveToCurrentRow(); |
| // check that the number of rows has increased |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS + 1); |
| assertTrue(findRowByPrimaryKey(rs, rowToInsert, 1)); |
| rs.absolute(COFFEE_HOUSES_ROWS + 1); |
| // Save off the original column values |
| String f2 = rs.getString(2); |
| int f3 = rs.getInt(3); |
| rs.updateString(2, "SMALLVILLE"); |
| rs.updateInt(3, 500); |
| // Validate the columns have been updated |
| assertTrue(rs.columnUpdated(2)); |
| assertTrue(rs.columnUpdated(3)); |
| // Undo the update and validate it has taken place |
| rs.absolute(COFFEE_HOUSES_ROWS + 1); |
| rs.undoUpdate(); |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| assertFalse(findRowByPrimaryKey(rs, rowToInsert, 1)); |
| rs.close(); |
| } |
| |
| /* |
| * Validate getOriginal returns a ResultSet which is a copy of the original |
| * RowSet |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void commonCachedRowSetTest0056(CachedRowSet rs) throws Exception { |
| String coffee = "Hazelnut"; |
| int sales = 100; |
| int id = 200; |
| Object[] updatedPkeys = {1, id, 3, 4, 5}; |
| // Change the coffee name and sales total for row 2 and save the |
| // previous values |
| rs.absolute(2); |
| int origId = rs.getInt(1); |
| String origCoffee = rs.getString(2); |
| int origSales = rs.getInt(5); |
| rs.updateInt(1, id); |
| rs.updateString(2, coffee); |
| rs.updateInt(5, sales); |
| // MetaData should match |
| try ( // Get the original original RowSet and validate that the changes |
| // are only made to the current, not the original |
| ResultSet rs1 = rs.getOriginal()) { |
| // MetaData should match |
| compareMetaData(rs.getMetaData(), rs1.getMetaData()); |
| assertTrue(rs1.isBeforeFirst()); |
| assertTrue(rs1.getConcurrency() == ResultSet.CONCUR_UPDATABLE); |
| assertTrue(rs1.getType() == ResultSet.TYPE_SCROLL_INSENSITIVE); |
| rs1.absolute(2); |
| // Check original rowset is not changed |
| assertTrue(rs1.getInt(1) == origId); |
| assertTrue(rs1.getString(2).equals(origCoffee)); |
| assertTrue(rs1.getInt(5) == origSales); |
| assertEquals(getPrimaryKeys(rs1), COFFEES_PRIMARY_KEYS); |
| // Check current rowset |
| assertTrue(rs.getInt(1) == id); |
| assertTrue(rs.getString(2).equals(coffee)); |
| assertTrue(rs.getInt(5) == sales); |
| assertEquals(getPrimaryKeys(rs), updatedPkeys); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate getOriginalRow returns a ResultSet which is a copy of the |
| * original row that was modified |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees") |
| public void commonCachedRowSetTest0057(CachedRowSet rs) throws Exception { |
| String coffee = "Hazelnut"; |
| int sales = 100; |
| int id = 200; |
| Object[] updatedPkeys = {1, id, 3, 4, 5}; |
| // Change the coffee name and sales total for row 2 and save the |
| // previous values |
| rs.absolute(2); |
| int origId = rs.getInt(1); |
| String origCoffee = rs.getString(2); |
| int origSales = rs.getInt(5); |
| rs.updateInt(1, id); |
| rs.updateString(2, coffee); |
| rs.updateInt(5, sales); |
| // MetaData should match |
| try ( // Get the original original row and validate that the changes |
| // are only made to the current, not the original |
| ResultSet rs1 = rs.getOriginalRow()) { |
| // MetaData should match |
| compareMetaData(rs.getMetaData(), rs1.getMetaData()); |
| assertTrue(rs1.isBeforeFirst()); |
| assertTrue(rs1.getConcurrency() == ResultSet.CONCUR_UPDATABLE); |
| assertTrue(rs1.getType() == ResultSet.TYPE_SCROLL_INSENSITIVE); |
| rs1.next(); |
| assertTrue(rs1.isFirst() && rs1.isLast()); |
| assertTrue(rs1.getRow() == 1); |
| // Check original row is not changed |
| assertTrue(rs1.getInt(1) == origId); |
| assertTrue(rs1.getString(2).equals(origCoffee)); |
| assertTrue(rs1.getInt(5) == origSales); |
| // Check current row |
| assertTrue(rs.getInt(1) == id); |
| assertTrue(rs.getString(2).equals(coffee)); |
| assertTrue(rs.getInt(5) == sales); |
| assertEquals(getPrimaryKeys(rs), updatedPkeys); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that restoreOrginal will restore the RowSet to its |
| * state prior to the insert of a row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0058(CachedRowSet rs) throws Exception { |
| int rowToInsert = 1961; |
| assertTrue(rs.size() == COFFEE_HOUSES_ROWS); |
| try ( // Add new row |
| CachedRowSet crs1 = rsf.createCachedRowSet()) { |
| rs.beforeFirst(); |
| crs1.populate(rs); |
| TestRowSetListener rsl = new TestRowSetListener(); |
| crs1.addRowSetListener(rsl); |
| crs1.moveToInsertRow(); |
| crs1.updateInt(1, rowToInsert); |
| crs1.updateString(2, "GOTHAM"); |
| crs1.updateInt(3, 3450); |
| crs1.updateInt(4, 2005); |
| crs1.updateInt(5, 5455); |
| crs1.insertRow(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROW_CHANGED)); |
| crs1.moveToCurrentRow(); |
| assertTrue(findRowByPrimaryKey(crs1, rowToInsert, 1)); |
| // Restore back to our original state and the |
| // previously inserted row should not be there |
| rsl.resetFlag(); |
| crs1.restoreOriginal(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED)); |
| assertTrue(crs1.isBeforeFirst()); |
| crs1.last(); |
| assertFalse(crs1.rowInserted()); |
| assertFalse(findRowByPrimaryKey(crs1, rowToInsert, 1)); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that restoreOrginal will restore the RowSet to its |
| * state prior to deleting a row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees", enabled = true) |
| public void commonCachedRowSetTest0059(CachedRowSet rs) throws Exception { |
| int rowToDelete = 2; |
| try (CachedRowSet crs1 = rsf.createCachedRowSet()) { |
| rs.beforeFirst(); |
| crs1.populate(rs); |
| TestRowSetListener rsl = new TestRowSetListener(); |
| crs1.addRowSetListener(rsl); |
| // Delete a row, the PK is also the absolute position as a List |
| // backs the RowSet |
| crs1.absolute(rowToDelete); |
| crs1.deleteRow(); |
| assertTrue(crs1.rowDeleted()); |
| assertFalse(findRowByPrimaryKey(crs1, rowToDelete, 1)); |
| // Restore back to our original state and the |
| // previously deleted row should be there |
| rsl.resetFlag(); |
| crs1.restoreOriginal(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED)); |
| assertTrue(crs1.isBeforeFirst()); |
| crs1.absolute(rowToDelete); |
| assertFalse(crs1.rowDeleted()); |
| assertTrue(findRowByPrimaryKey(crs1, rowToDelete, 1)); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Validate that restoreOrginal will restore the RowSet to its |
| * state prior to updating a row |
| */ |
| @Test(dataProvider = "rowsetUsingCoffees", enabled = true) |
| public void commonCachedRowSetTest0060(CachedRowSet rs) throws Exception { |
| int rowToUpdate = 2; |
| String coffee = "Hazelnut"; |
| try (CachedRowSet crs1 = rsf.createCachedRowSet()) { |
| rs.beforeFirst(); |
| crs1.populate(rs); |
| TestRowSetListener rsl = new TestRowSetListener(); |
| crs1.addRowSetListener(rsl); |
| // Delete a row, the PK is also the absolute position as a List |
| // backs the RowSet |
| crs1.absolute(rowToUpdate); |
| String origCoffee = crs1.getString(2); |
| crs1.updateString(2, coffee); |
| assertTrue(crs1.columnUpdated(2)); |
| crs1.updateRow(); |
| assertTrue(crs1.rowUpdated()); |
| assertFalse(origCoffee.equals(crs1.getString(2))); |
| // Restore back to our original state and the |
| // previous value for the column within the row should be there |
| rsl.resetFlag(); |
| crs1.restoreOriginal(); |
| assertTrue(rsl.isNotified(TestRowSetListener.ROWSET_CHANGED)); |
| assertTrue(crs1.isBeforeFirst()); |
| // absolute() is failing for some reason so need to look at this later |
| crs1.next(); |
| crs1.next(); |
| assertFalse(crs1.columnUpdated(2)); |
| assertFalse(crs1.rowUpdated()); |
| assertTrue(origCoffee.equals(crs1.getString(2))); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Initialize a RowSet via the populate method. Validate it matches |
| * the original ResultSet |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0061(CachedRowSet rs) throws Exception { |
| try (CachedRowSet crs1 = rsf.createCachedRowSet()) { |
| rs.beforeFirst(); |
| crs1.populate(rs); |
| compareRowSets(rs, crs1); |
| } |
| rs.close(); |
| } |
| |
| /* |
| * Initialize a RowSet via the populate method specifying a starting row. |
| * Validate it matches the original ResultSet starting for the specofied |
| * offset |
| */ |
| @Test(dataProvider = "rowsetUsingCoffeeHouses") |
| public void commonCachedRowSetTest0062(CachedRowSet rs) throws Exception { |
| Object[] expectedRows = { |
| 32001, 10042, 10024, 10039, 10041, 33005, 33010, 10035, 10037, |
| 10034, 32004 |
| }; |
| int startingRow = 4; |
| try (CachedRowSet crs1 = rsf.createCachedRowSet()) { |
| rs.beforeFirst(); |
| crs1.populate(rs, startingRow); |
| assertEquals(crs1.size(), COFFEE_HOUSES_ROWS - startingRow + 1); |
| assertEquals(getPrimaryKeys(crs1), expectedRows); |
| } |
| rs.close(); |
| } |
| |
| } |
