| /* |
| * Copyright (C) 2007 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package libcore.java.sql; |
| |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| import java.sql.Statement; |
| import tests.support.DatabaseCreator; |
| |
| public final class OldResultSetTest extends OldSQLTest { |
| |
| ResultSet target = null; |
| ResultSet emptyTarget = null; |
| ResultSet scrollableTarget = null; |
| ResultSet writableTarget = null; |
| Statement stForward = null; |
| Statement stScrollable = null; |
| Statement stWritable = null; |
| final String selectAllAnimals = "select id, name from zoo"; |
| final String selectEmptyTable = "select * from "+DatabaseCreator.SIMPLE_TABLE1; |
| |
| @Override public void setUp() throws Exception { |
| super.setUp(); |
| |
| conn.setAutoCommit(false); |
| stForward = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| stForward.execute(selectAllAnimals); |
| target = stForward.getResultSet(); |
| assertNotNull(target); |
| |
| // empty table |
| stForward = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| stForward.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1); |
| stForward.execute(selectEmptyTable); |
| emptyTarget = stForward.getResultSet(); |
| } |
| |
| public void tearDown() throws SQLException { |
| super.tearDown(); |
| target.close(); |
| stForward.close(); |
| } |
| |
| public void testAbsolute() throws SQLException { |
| assertTrue(target.isBeforeFirst()); |
| assertFalse(target.absolute(0)); |
| assertTrue(target.absolute(1)); |
| assertTrue(target.isFirst()); |
| assertTrue(target.absolute(-1)); |
| assertTrue(target.isLast()); |
| target.next(); |
| assertTrue(target.isAfterLast()); |
| } |
| |
| // res.close() does not wrap up |
| public void testAfterLast() throws SQLException { |
| target.afterLast(); |
| assertTrue(target.isAfterLast()); |
| assertFalse(target.next()); |
| |
| emptyTarget.afterLast(); |
| assertFalse(emptyTarget.isAfterLast()); |
| |
| try { |
| target.close(); |
| target.afterLast(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| } |
| } |
| |
| // statement.close() does not wrap up |
| public void testBeforeFirst() throws SQLException { |
| target.beforeFirst(); |
| assertTrue(target.isBeforeFirst()); |
| assertTrue(target.next()); |
| assertFalse(target.isBeforeFirst()); |
| |
| emptyTarget.beforeFirst(); |
| assertFalse(emptyTarget.isBeforeFirst()); |
| |
| try { |
| target.close(); |
| target.beforeFirst(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| } |
| } |
| |
| /** |
| * According to the JDBC spec close has to "Releases this ResultSet |
| * object's database and JDBC resources immediately", and this implies |
| * the fields should be released as well (so that garbage collection |
| * can take place) |
| */ |
| public void testClose1() { |
| try { |
| target.close(); |
| target.next(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test that exception in one prepared statement does not affect second |
| * statement. (Atomicity Rule) |
| */ |
| public void testClose() throws SQLException { |
| PreparedStatement ps1 = null; |
| PreparedStatement ps2 = null; |
| try { |
| Statement s = conn.createStatement(); |
| s.addBatch("create table t1 (a text);"); |
| |
| s.addBatch("insert into t1 values('abc');"); |
| s.addBatch("insert into t1 values('def');"); |
| s.addBatch("insert into t1 values('ghi');"); |
| s.executeBatch(); |
| s.close(); |
| |
| conn.commit(); |
| ps1 = conn.prepareStatement("select * from t1"); |
| ps2 = conn.prepareStatement("select * from t1 whe a like '?000'"); |
| |
| ResultSet rs1 = ps1.executeQuery(); |
| try { |
| ResultSet rs2 = ps2.executeQuery(); |
| while (rs2.next()){ |
| // do nothing |
| } |
| fail("Should get SQLException"); |
| } catch (SQLException sqle) { |
| // ok : Division by zero |
| } |
| |
| // Although exception happened on ps2 rs1 should still work |
| // Isolation property if ACID rules |
| |
| while (rs1.next()) { |
| // do nothing: switching of rows should be possible |
| } |
| |
| conn.commit(); |
| |
| rs1.close(); |
| ps1.close(); |
| ps2.close(); |
| } finally { |
| try { |
| if (ps1 != null) ps1.close(); |
| if (ps2 != null) ps2.close(); |
| conn.rollback(); |
| } catch (SQLException e) { |
| // TODO Auto-generated catch block |
| e.printStackTrace(); |
| } |
| } |
| } |
| |
| public void testFindColumn() throws SQLException { |
| assertEquals(1, target.findColumn("id")); |
| assertEquals(2, target.findColumn("name")); |
| |
| try { |
| target.findColumn("bla"); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| // statement.close() does not wrap up |
| public void testtestFirst() throws SQLException { |
| assertFalse(emptyTarget.first()); |
| assertTrue(target.first()); |
| |
| try { |
| target.close(); |
| // releases all resources such that it can be finalized! |
| target.first(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| } |
| } |
| |
| // statement.close() does not wrap up |
| public void testtestIsAfterLast() throws SQLException { |
| assertFalse(target.isAfterLast()); |
| target.absolute(-1); // last |
| target.next(); |
| assertTrue(target.isAfterLast()); |
| assertFalse(emptyTarget.isAfterLast()); |
| |
| try { |
| target.close(); |
| // releases all resources such that it can be finalized! |
| target.isAfterLast(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| } |
| } |
| |
| // In Second code block assertion fails. statement.close() does not wrap up |
| public void testtestIsBeforeFirst() throws SQLException { |
| assertTrue(target.isBeforeFirst()); |
| assertTrue(target.next()); |
| assertFalse(target.isBeforeFirst()); |
| assertTrue(target.isFirst()); |
| assertTrue(emptyTarget.isBeforeFirst()); |
| |
| try { |
| target.close(); |
| // releases all resources such that it can be finalized! |
| target.isBeforeFirst(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| // statement.close() does not wrap up |
| public void testtestIsFirst() throws SQLException { |
| assertFalse(target.isFirst()); |
| target.first(); |
| assertTrue(target.isFirst()); |
| target.next(); |
| assertFalse(target.isFirst()); |
| |
| assertFalse(emptyTarget.isFirst()); |
| |
| try { |
| target.close(); |
| // releases all resources such that it can be finalized! |
| target.isFirst(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| } |
| } |
| |
| /** |
| * Second block first assertion fails. Is Last should evaluate true if the |
| * row on which the cursor is actually provides a result.statment.close() |
| * does not wrap up |
| */ |
| public void testtestIsLast() throws SQLException { |
| assertFalse(target.isLast()); |
| target.absolute(-1); |
| assertTrue(target.isLast()); |
| |
| //check default value no valid row |
| assertFalse(emptyTarget.isLast()); |
| assertFalse(emptyTarget.next()); |
| assertFalse(emptyTarget.isLast()); |
| |
| try { |
| target.close(); |
| target.isLast(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| // statement.close() does not wrap up |
| public void testtestLast() throws SQLException { |
| assertFalse(target.isLast()); |
| target.last(); |
| assertTrue(target.isLast()); |
| |
| try { |
| target.close(); |
| target.last(); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * SQLException checking test fails. Clearing of warnings and closed streams |
| * not supported. |
| */ |
| public void testNext() throws SQLException { |
| //before first - first |
| assertTrue(target.next()); |
| //first - second |
| assertTrue(target.next()); |
| //after last |
| assertFalse(target.next()); |
| assertTrue(target.isAfterLast()); |
| // one more |
| assertFalse(target.next()); |
| |
| assertFalse(emptyTarget.next()); |
| |
| target.close(); |
| try { |
| target.next(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| public void testPrevious() throws SQLException { |
| target.first(); |
| target.previous(); |
| assertTrue(target.isBeforeFirst()); |
| |
| target.last(); |
| target.next(); |
| target.previous(); |
| assertFalse(target.isAfterLast()); |
| |
| target.close(); |
| try { |
| target.previous(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| // no exception is thrown when moving cursor backwards on forward only statement |
| public void testRelative() throws SQLException { |
| |
| // forward only |
| int initialRow = target.getRow(); |
| assertFalse(target.relative(0)); |
| assertEquals(initialRow, target.getRow()); |
| |
| assertTrue(target.relative(1)); |
| assertTrue(target.isFirst()); |
| assertEquals(1, target.getRow()); |
| |
| assertTrue(target.relative(1)); |
| assertFalse(target.isFirst()); |
| assertEquals(2, target.getRow()); |
| assertFalse(target.relative(2)); |
| |
| try { |
| // should not be able to scroll backwards in forward only RS |
| target.relative(-2); |
| assertEquals(2,target.getRow()); |
| fail("Should get SQLException"); |
| } catch (SQLException e) { |
| // ok |
| } catch (Exception e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| |
| assertFalse(emptyTarget.relative(Integer.MAX_VALUE)); |
| assertTrue(emptyTarget.isAfterLast()); |
| } |
| |
| // Scrollable resultSet. Not supported |
| public void testRelativeScrollableResultSet() throws SQLException { |
| // scrollable resultSet |
| int initialRow = scrollableTarget.getRow(); |
| assertFalse(scrollableTarget.relative(0)); |
| assertEquals(initialRow, scrollableTarget.getRow()); |
| |
| assertTrue(scrollableTarget.relative(1)); |
| assertTrue(scrollableTarget.isFirst()); |
| assertEquals(1, scrollableTarget.getRow()); |
| |
| assertTrue(scrollableTarget.relative(1)); |
| assertFalse(scrollableTarget.isFirst()); |
| |
| assertEquals(2, scrollableTarget.getRow()); |
| assertFalse(scrollableTarget.relative(2)); |
| scrollableTarget.relative(-2); |
| assertEquals(2,scrollableTarget.getRow()); |
| |
| assertFalse(scrollableTarget.relative(Integer.MIN_VALUE)); |
| assertTrue(scrollableTarget.isBeforeFirst()); |
| |
| stScrollable.close(); |
| try { |
| scrollableTarget.relative(1); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| // not supported |
| public void testUpdateObjectStringObject() throws SQLException { |
| writableTarget.next(); |
| writableTarget.updateObject("family","bird"); |
| |
| try { |
| target.next(); |
| target.updateObject("family","bird"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| fail("Unexpected exception: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * Only exception testing. Missing testing for wrong type |
| */ |
| public void testUpdateStringStringString() throws Exception { |
| writableTarget.next(); |
| writableTarget.updateString("family","bird"); |
| |
| // non writable target. |
| try { |
| target.next(); |
| target.updateString("family","bird"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| |
| // writable but wrong type |
| target.updateString(1,"test"); |
| |
| target.close(); |
| |
| // Exception test |
| try { |
| target.updateString("family", "test"); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * Test method for {@link java.sql.ResultSet#wasNull()}. |
| * Spec sais: if something was read... -> if nothing was read it should be false |
| */ |
| public void testWasNull() throws SQLException { |
| // Check default: select statement executed but no get on target called yet |
| // Either false or throw an exception. |
| try { |
| assertFalse(target.wasNull()); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| stForward.execute("insert into zoo values(8,null,null);"); |
| stForward.execute(selectAllAnimals); |
| target = stForward.getResultSet(); |
| assertNotNull(target); |
| assertTrue(target.last()); |
| assertNull(target.getObject(2)); |
| assertTrue(target.wasNull()); |
| assertNotNull(target.getObject(1)); |
| assertFalse(target.wasNull()); |
| |
| target.close(); |
| try { |
| target.wasNull(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| } |