| /* |
| * 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 tests.sql; |
| |
| import dalvik.annotation.KnownFailure; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargets; |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetNew; |
| |
| import java.io.IOException; |
| import java.sql.Connection; |
| import java.sql.DatabaseMetaData; |
| import java.sql.DriverManager; |
| import java.sql.SQLWarning; |
| import java.sql.Savepoint; |
| import java.sql.Statement; |
| import java.sql.PreparedStatement; |
| import java.sql.ResultSet; |
| import java.sql.SQLException; |
| |
| import java.sql.CallableStatement; |
| import java.util.Map; |
| |
| import junit.framework.Test; |
| |
| @TestTargetClass(Connection.class) |
| public class ConnectionTest extends SQLTest { |
| |
| /** |
| * @test {@link java.sql.Connection#createStatement()} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "createStatement", |
| args = {} |
| ) |
| public void testCreateStatement() { |
| |
| Statement statement = null; |
| try { |
| statement = conn.createStatement(); |
| assertNotNull(statement); |
| //check default values |
| assertEquals(ResultSet.FETCH_UNKNOWN, statement.getFetchDirection()); |
| assertNull(statement.getWarnings()); |
| assertTrue(statement.getQueryTimeout() > 0); |
| } catch (SQLException sqle) { |
| fail("SQL Exception was thrown: " + sqle.getMessage()); |
| } catch (Exception e) { |
| fail("Unexpected Exception " + e.getMessage()); |
| } |
| try { |
| conn.close(); |
| statement.executeQuery("select * from zoo"); |
| fail("SQLException is not thrown after close"); |
| } catch (SQLException e) { |
| // expected |
| } |
| } |
| |
| /** |
| * @test {@link java.sql.Connection#createStatement(int resultSetType, int |
| * resultSetConcurrency)} |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Exception tests fail.", |
| method = "createStatement", |
| args = {int.class, int.class} |
| ) |
| @KnownFailure("Scrolling on a forward only RS not allowed. conn.close() does not wrap up") |
| public void testCreateStatement_int_int() throws SQLException { |
| Statement st = null; |
| ResultSet rs = null; |
| |
| // test read only |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.deleteRow(); |
| fail("Could delete row for READ_ONLY ResultSet"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| // test forward only: scrolling not allowed |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.absolute(1); |
| rs.previous(); |
| fail("Could scroll backwards"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| // test forward only |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.last(); |
| rs.first(); |
| fail("Could scroll backwards"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| |
| // test updating ResultSets |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("parrot", (rs.getString(1))); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("bird", (rs.getString(1))); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| conn.close(); |
| |
| try { |
| // exception is not specified for this case |
| conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, -1); |
| fail("Illigal arguments: should return exception."); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| try { |
| // exception is not specified for this case |
| conn.createStatement(Integer.MIN_VALUE, ResultSet.CONCUR_READ_ONLY); |
| fail("Illigal arguments: should return exception."); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#createStatement(int resultSetType, int |
| * resultSetConcurrency, int resultSetHoldability) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "ResultSet.HOLD_CURSORS_AT_COMMIT", |
| method = "createStatement", |
| args = {int.class, int.class, int.class} |
| ) |
| public void testCreateStatement_int_int_int() { |
| Statement st = null; |
| try { |
| assertNotNull(conn); |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| assertNotNull(st); |
| st.execute("select id, name from zoo"); |
| ResultSet rs = st.getResultSet(); |
| rs.next(); |
| int pos = rs.getRow(); |
| conn.commit(); |
| assertEquals("ResultSet cursor position has changed",pos, rs.getRow()); |
| try { |
| rs.close(); |
| } catch (SQLException sqle) { |
| fail("Unexpected exception was thrown during closing ResultSet"); |
| } |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| if (st != null) st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, -100); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| //ok |
| } |
| |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "ResultSet.CLOSE_CURSORS_AT_COMMIT as argument is not supported", |
| method = "createStatement", |
| args = {int.class, int.class, int.class} |
| ) |
| @KnownFailure("not supported") |
| public void testCreateStatementIntIntIntNotSupported() { |
| Statement st = null; |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| assertNotNull(st); |
| st.execute("select id, name from zoo"); |
| ResultSet rs = st.getResultSet(); |
| |
| try { |
| rs.close(); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| if (st != null) { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#getMetaData() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException test fails", |
| method = "getMetaData", |
| args = {} |
| ) |
| @KnownFailure("conn.close() does not wrap up") |
| public void testGetMetaData() throws SQLException{ |
| try { |
| DatabaseMetaData md = conn.getMetaData(); |
| Connection con = md.getConnection(); |
| assertEquals(conn, con); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } |
| |
| conn.close(); |
| try { |
| conn.getMetaData(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#clearWarnings() |
| * |
| * TODO clearWarnings is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "test fails. not supported. always returns null.", |
| method = "clearWarnings", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testClearWarnings() throws SQLException { |
| |
| try { |
| SQLWarning w = conn.getWarnings(); |
| assertNull(w); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| |
| |
| Statement st = null; |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoo"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| assertNotNull(conn.getWarnings()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.clearWarnings(); |
| SQLWarning w = conn.getWarnings(); |
| assertNull(w); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| |
| try { |
| st = conn.createStatement(); |
| st.execute("select monkey from zoo"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| assertEquals("SQLite.Exception: error in prepare/compile",e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| //Test for correct functionality |
| try { |
| SQLWarning w = conn.getWarnings(); |
| assertNotNull(w); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| |
| conn.close(); |
| try { |
| conn.clearWarnings(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getWarnings() |
| * |
| * TODO GetWarnings is not supported: returns null |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported. always returns null. SQLException test fails", |
| method = "getWarnings", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testGetWarnings() throws SQLException { |
| Statement st = null; |
| int errorCode1 = -1; |
| int errorCode2 = -1; |
| |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoooo"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| // expected |
| errorCode1 = e.getErrorCode(); |
| } |
| |
| try { |
| SQLWarning wrs = conn.getWarnings(); |
| assertNull(wrs); |
| } catch (Exception e) { |
| fail("Change test implementation: get warnings is supported now"); |
| } |
| |
| // tests implementation: but errorcodes need to change too -> change impl. |
| /* |
| Statement st = null; |
| int errorCode1 = -1; |
| int errorCode2 = -1; |
| |
| try { |
| st = conn.createStatement(); |
| st.execute("select animals from zoooo"); |
| fail("SQLException was not thrown"); |
| } catch (SQLException e) { |
| // expected |
| errorCode1 = e.getErrorCode(); |
| } |
| |
| try { |
| SQLWarning wrs = conn.getWarnings(); |
| assertNotNull(wrs); |
| assertEquals(errorCode1, wrs.getErrorCode()); |
| assertNull(wrs.getNextWarning()); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| try { |
| st.execute("select horse from zoooooo"); |
| } catch (SQLException e) { |
| // expected |
| errorCode2 = e.getErrorCode(); |
| } |
| |
| try { |
| SQLWarning wrs = conn.getWarnings(); |
| assertEquals(errorCode1, wrs.getErrorCode()); |
| assertNotNull(wrs.getNextWarning()); |
| assertEquals(errorCode2, wrs.getErrorCode()); |
| } catch (Exception e) { |
| fail("Unexpected Exception: " + e.getMessage()); |
| } |
| |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| |
| */ |
| |
| conn.close(); |
| try { |
| conn.getWarnings(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#getAutoCommit() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException checking missed", |
| method = "getAutoCommit", |
| args = {} |
| ) |
| public void testGetAutoCommit() { |
| try { |
| conn.setAutoCommit(true); |
| assertTrue(conn.getAutoCommit()); |
| conn.setAutoCommit(false); |
| assertFalse(conn.getAutoCommit()); |
| conn.setAutoCommit(true); |
| assertTrue(conn.getAutoCommit()); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#setAutoCommit(boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "SQLException test throws exception", |
| method = "setAutoCommit", |
| args = {boolean.class} |
| ) |
| @KnownFailure("conn.close() does not wrap up") |
| public void testSetAutoCommit() throws SQLException { |
| |
| Statement st = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| try { |
| conn.setAutoCommit(true); |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Chichichi', 'monkey');"); |
| conn.commit(); |
| } catch (SQLException e) { |
| //ok |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| // even though exception was thrown value is committed |
| try { |
| st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(3, getCount(rs)); |
| } catch (SQLException e) { |
| fail("Unexpected Exception thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| |
| try { |
| conn.setAutoCommit(false); |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Burenka', 'cow');"); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(4, getCount(rs)); |
| conn.commit(); |
| // Check cursors closed after commit |
| rs1 = st.getResultSet(); |
| assertEquals(0, getCount(rs1)); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| rs1.close(); |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| conn.close(); |
| |
| try { |
| conn.setAutoCommit(true); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#isReadOnly() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Instead of SQLException nullpointer exception is thrown.", |
| method = "isReadOnly", |
| args = {} |
| ) |
| @KnownFailure("conn.close() does not wrap up") |
| public void testIsReadOnly() throws SQLException { |
| try { |
| conn.setReadOnly(true); |
| assertTrue(conn.isReadOnly()); |
| conn.setReadOnly(false); |
| assertFalse(conn.isReadOnly()); |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.getMessage()); |
| } |
| |
| conn.close(); |
| try { |
| conn.isReadOnly(); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#setReadOnly(boolean) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Not supported. test fails", |
| method = "setReadOnly", |
| args = {boolean.class} |
| ) |
| @KnownFailure("not supported") |
| public void testSetReadOnly() throws SQLException { |
| |
| // Pseudo test: not supported test |
| Statement st = null; |
| try { |
| conn.setReadOnly(true); |
| st = conn.createStatement(); |
| st.execute("insert into zoo (id, name, family) values (3, 'ChiChiChi', 'monkey');"); |
| // fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| fail("Set readonly is actually implemented: activate correct test"); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| // test for correct implementation |
| st = null; |
| try { |
| conn.setReadOnly(true); |
| st = conn.createStatement(); |
| st.execute("insert into zoo (id, name, family) values (3, 'ChiChiChi', 'monkey');"); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.setReadOnly(true); |
| st = conn.createStatement(); |
| st.executeUpdate("insert into zoo (id, name, family) values (4, 'ChaChaCha', 'monkey');"); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.setReadOnly(false); |
| st = conn.createStatement(); |
| st.execute("insert into zoo (id, name, family) values (4, 'ChiChiChi', 'monkey');"); |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| conn.close(); |
| try { |
| conn.setReadOnly(true); |
| fail("Exception expected"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getHoldability() |
| * |
| * TODO ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "+option ResultSet.CLOSE_CURSORS_AT_COMMIT not supported. SQLException test fails.", |
| method = "getHoldability", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testGetHoldability() throws SQLException { |
| try { |
| conn.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn |
| .getHoldability()); |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.getMessage()); |
| } |
| |
| try { |
| conn.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, conn |
| .getHoldability()); |
| } catch (SQLException e) { |
| assertEquals("not supported", e.getMessage()); |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.getHoldability(); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#setHoldability(int) |
| * |
| * TODO ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported", |
| method = "setHoldability", |
| args = {int.class} |
| ) |
| @KnownFailure("not supported") |
| public void testSetHoldability() { |
| Statement st = null; |
| try { |
| conn.setAutoCommit(false); |
| conn.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, conn |
| .getHoldability()); |
| st = conn.createStatement(); |
| st.execute("insert into zoo (id, name, family) values (4, 'ChiChiChi', 'monkey');"); |
| ResultSet rs = st.getResultSet(); |
| conn.commit(); |
| try { |
| rs.next(); |
| } catch (SQLException sqle) { |
| //ok |
| } |
| conn.setHoldability(ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, conn |
| .getHoldability()); |
| st = conn.createStatement(); |
| st.execute("insert into zoo (id, name, family) values (4, 'ChiChiChi', 'monkey');"); |
| rs = st.getResultSet(); |
| conn.commit(); |
| try { |
| rs.next(); |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.getMessage()); |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| conn.setHoldability(-1); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getTransactionIsolation() |
| * |
| * TODO only Connection.TRANSACTION_SERIALIZABLE is supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "SQLException testing throws exception. Connection.TRANSACTION_SERIALIZABLE.", |
| method = "getTransactionIsolation", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testGetTransactionIsolation() throws SQLException { |
| try { |
| conn |
| .setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED); |
| assertEquals(Connection.TRANSACTION_READ_UNCOMMITTED, conn |
| .getTransactionIsolation()); |
| conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); |
| assertEquals(Connection.TRANSACTION_READ_COMMITTED, conn |
| .getTransactionIsolation()); |
| conn |
| .setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); |
| assertEquals(Connection.TRANSACTION_REPEATABLE_READ, conn |
| .getTransactionIsolation()); |
| conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); |
| assertEquals(Connection.TRANSACTION_SERIALIZABLE, conn |
| .getTransactionIsolation()); |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.getTransactionIsolation(); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getTransactionIsolation() |
| * |
| * TODO only Connection.TRANSACTION_SERIALIZABLE is supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "not supported options", |
| method = "getTransactionIsolation", |
| args = {} |
| ) |
| public void testGetTransactionIsolationNotSupported() throws SQLException { |
| /* |
| try { |
| conn |
| .setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED); |
| assertEquals(Connection.TRANSACTION_READ_UNCOMMITTED, conn |
| .getTransactionIsolation()); |
| conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); |
| assertEquals(Connection.TRANSACTION_READ_COMMITTED, conn |
| .getTransactionIsolation()); |
| conn |
| .setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); |
| assertEquals(Connection.TRANSACTION_REPEATABLE_READ, conn |
| .getTransactionIsolation()); |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#setTransactionIsolation(int) |
| * |
| * TODO only Connection.TRANSACTION_SERIALIZABLE is supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "not fully supported", |
| method = "setTransactionIsolation", |
| args = {int.class} |
| ) |
| public void testSetTransactionIsolation() { |
| try { |
| // conn |
| // .setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED); |
| // assertEquals(Connection.TRANSACTION_READ_UNCOMMITTED, conn |
| // .getTransactionIsolation()); |
| // conn.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED); |
| // assertEquals(Connection.TRANSACTION_READ_COMMITTED, conn |
| // .getTransactionIsolation()); |
| // conn |
| // .setTransactionIsolation(Connection.TRANSACTION_REPEATABLE_READ); |
| // assertEquals(Connection.TRANSACTION_REPEATABLE_READ, conn |
| // .getTransactionIsolation()); |
| conn.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE); |
| assertEquals(Connection.TRANSACTION_SERIALIZABLE, conn |
| .getTransactionIsolation()); |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| |
| try { |
| conn.setTransactionIsolation(0); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#setCatalog(String catalog) |
| * |
| * TODO setCatalog method does nothing: Hint default catalog sqlite_master. |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setCatalog", |
| args = {java.lang.String.class} |
| ) |
| public void testSetCatalog() { |
| |
| String[] catalogs = { "test", "test1", "test" }; |
| Statement st = null; |
| try { |
| for (int i = 0; i < catalogs.length; i++) { |
| conn.setCatalog(catalogs[i]); |
| assertNull(catalogs[i], conn.getCatalog()); |
| st = conn.createStatement(); |
| st |
| .equals("create table test_table (id integer not null, name varchar(20), primary key(id));"); |
| st.equals("drop table test_table;"); |
| |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| /* |
| String[] catalogs = { "test"}; |
| Statement st = null; |
| try { |
| for (int i = 0; i < catalogs.length; i++) { |
| conn.setCatalog(catalogs[i]); |
| fail("illegal catalog name"); |
| assertEquals(catalogs[i], conn.getCatalog()); |
| st = conn.createStatement(); |
| st |
| .equals("create table test_table (id integer not null, name varchar(20), primary key(id));"); |
| st.equals("drop table test_table;"); |
| } |
| } catch (SQLException sqle) { |
| System.out.println("TODO: Test for correct error message: name with ,\"sqlite_\" prefix expected"); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| String[] catalogs = { "sqlite_test", "sqlite_test1", "sqlite_test" }; |
| Statement st = null; |
| try { |
| for (int i = 0; i < catalogs.length; i++) { |
| conn.setCatalog(catalogs[i]); |
| assertEquals(catalogs[i], conn.getCatalog()); |
| st = conn.createStatement(); |
| st |
| .equals("create table test_table (id integer not null, name varchar(20), primary key(id));"); |
| st.equals("drop table test_table;"); |
| |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown"); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| conn.setCatalog(null); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| |
| try { |
| conn.setCatalog("not_exist"); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| */ |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getCatalog() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported. test fails", |
| method = "getCatalog", |
| args = {} |
| ) |
| @KnownFailure("not supported") |
| public void testGetCatalog() throws SQLException { |
| |
| |
| // test default catalog |
| try { |
| assertEquals("sqlite_master", conn.getCatalog()); |
| } catch (SQLException sqle) { |
| fail("SQL Exception " + sqle.getMessage()); |
| } catch (Exception e) { |
| fail("Unexpected Exception " + e.getMessage()); |
| } |
| |
| |
| String[] catalogs = { "sqlite_test", "sqlite_test1", "sqlite_test" }; |
| Statement st = null; |
| try { |
| for (int i = 0; i < catalogs.length; i++) { |
| conn.setCatalog(catalogs[i]); |
| assertNull(conn.getCatalog()); |
| } |
| } catch (SQLException sqle) { |
| fail("SQL Exception " + sqle.getMessage()); |
| } catch (Exception e) { |
| fail("Reeimplement tests now that the method is implemented"); |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.getCatalog(); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#setTypeMap(Map<String,Class<?>> map) |
| * |
| * TODO setTypeMap is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setTypeMap", |
| args = {java.util.Map.class} |
| ) |
| public void testSetTypeMap() { |
| /* |
| try { |
| java.util.Map map = conn.getTypeMap(); |
| map |
| .put( |
| "org.apache.harmony.sql.tests.java.sql.TestHelper_Connection1", |
| Class.forName("TestHelper_Connection1")); |
| conn.setTypeMap(map); |
| assertEquals(map, conn.getTypeMap()); |
| } catch (SQLException sqle) { |
| //ok |
| } catch (Exception e) { |
| fail("Unexpected Exception " + e.getMessage()); |
| } |
| |
| try { |
| conn.setTypeMap(null); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| */ |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#getTypeMap() |
| * |
| * TODO getTypeMap is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "getTypeMap", |
| args = {} |
| ) |
| public void testGetTypeMap() throws SQLException { |
| /* |
| try { |
| java.util.Map map = conn.getTypeMap(); |
| map |
| .put( |
| "org.apache.harmony.sql.tests.java.sql.TestHelper_Connection1", |
| Class.forName("TestHelper_Connection1")); |
| conn.setTypeMap(map); |
| assertEquals(map, conn.getTypeMap()); |
| } catch (SQLException sqle) { |
| //ok |
| } catch (Exception e) { |
| fail("Unexpected Exception " + e.getMessage()); |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.setTypeMap(null); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#nativeSQL(String sql) |
| * |
| * TODO nativeSQL is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "nativeSQL", |
| args = {java.lang.String.class} |
| ) |
| public void testNativeSQL() throws SQLException{ |
| String[] queries = { |
| "select * from zoo;", |
| "insert into zoo (id, name, family) values (3, 'Chichichi', 'monkey');", |
| "create table zoo_office(id integer not null, name varchar(20), primary key(id));", |
| "drop table zoo_office;" }; |
| String[] native_queries = { |
| "select * from zoo;", |
| "insert into zoo (id, name, family) values (3, 'Chichichi', 'monkey');", |
| "create table zoo_office(id integer not null, name varchar(20), primary key(id));", |
| "drop table zoo_office;" }; |
| Statement st = null; |
| String nativeQuery = ""; |
| try { |
| for (int i = 0; i < queries.length; i++) { |
| nativeQuery = conn.nativeSQL(queries[i]); |
| assertEquals(native_queries[i], nativeQuery); |
| st = conn.createStatement(); |
| st.execute(nativeQuery); |
| } |
| } catch (SQLException sqle) { |
| //ok |
| } catch (Exception e) { |
| fail("Unexpected Exception " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| String[] inc_queries = { "", " ", "not query" }; |
| for (int i = 0; i < inc_queries.length; i++) { |
| try { |
| nativeQuery = conn.nativeSQL(inc_queries[i]); |
| assertEquals(inc_queries[i], nativeQuery); |
| } catch (SQLException e) { |
| assertEquals("not supported",e.getMessage()); |
| } |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.nativeSQL(inc_queries[0]); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareCall(String sql) |
| * |
| * TODO prepareCall is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "prepareCall", |
| args = {java.lang.String.class} |
| ) |
| public void testPrepareCall() throws SQLException { |
| CallableStatement cstmt = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| Statement st = null; |
| Statement st1 = null; |
| try { |
| cstmt = conn.prepareCall("call welcomeAnimal(3, 'Petya', 'Cock')"); |
| st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(2, getCount(rs)); |
| cstmt.execute(); |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(3, getCount(rs1)); |
| |
| } catch (SQLException e) { |
| //ok not supported |
| } finally { |
| try { |
| st.close(); |
| st1.close(); |
| rs.close(); |
| rs1.close(); |
| cstmt.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| |
| try { |
| conn.prepareCall("welcomeAnimal(4, 'Petya', 'Cock')"); |
| fail("SQL Exception is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| |
| try { |
| conn.prepareCall(null); |
| fail("SQL Exception is not thrown"); |
| } catch (SQLException e) { |
| // expected |
| } |
| |
| // Exception checking |
| |
| conn.close(); |
| |
| try { |
| conn.prepareCall(""); |
| fail("Could execute statement on closed connection."); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareCall(String sql, int resultSetType, int |
| * resultSetConcurrency) |
| * |
| * TODO prepareCall is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "prepareCall", |
| args = {java.lang.String.class, int.class, int.class} |
| ) |
| public void testPrepareCall_String_int_int() { |
| CallableStatement cstmt = null; |
| ResultSet rs = null; |
| |
| try { |
| String query = "call welcomeAnimal(3, 'Petya', 'Cock')"; |
| cstmt = conn.prepareCall(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| /* |
| try { |
| String query = "call welcomeAnimal(3, 'Petya', 'Dino')"; |
| cstmt = conn.prepareCall(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| cstmt.execute("select id, name from zoo"); |
| rs = cstmt.getResultSet(); |
| try { |
| rs.deleteRow(); |
| fail("Can delete row for READ_ONLY ResultSet"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| try { |
| rs.absolute(0); |
| fail("Can move cursor to the last position for TYPE_FORWARD_ONLY ResultSet"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| cstmt.close(); |
| } catch (Exception ee) { |
| } |
| } |
| Statement st = null; |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("parrot", (rs.getString(1))); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("bird", (rs.getString(1))); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, -1); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| try { |
| conn.createStatement(Integer.MIN_VALUE, ResultSet.CONCUR_READ_ONLY); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareCall(String sql, int resultSetType, int |
| * resultSetConcurrency, int resultSetHoldability) |
| * |
| * TODO prepareCall is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "prepareCall", |
| args = {java.lang.String.class, int.class, int.class, int.class} |
| ) |
| public void testPrepareCall_String_int_int_int() { |
| CallableStatement cstmt = null; |
| ResultSet rs = null; |
| |
| try { |
| String query = "call welcomeAnimal(?, ?, ?)"; |
| cstmt = conn.prepareCall(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| } catch (SQLException e) { |
| //ok |
| } |
| /* |
| try { |
| String query = "call welcomeAnimal(?, ?, ?)"; |
| cstmt = conn.prepareCall(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| cstmt.setInt(1, 3); |
| cstmt.setString(2, "Petya"); |
| cstmt.setString(3, "Cock"); |
| cstmt.execute("select id, name from zoo"); |
| rs = cstmt.getResultSet(); |
| try { |
| rs.close(); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| fail("Unexpected exception was thrown during closing ResultSet"); |
| } |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| cstmt.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| Statement st = null; |
| |
| try { |
| st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.close(); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } |
| |
| try { |
| conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, -100); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| */ |
| |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareStatement(String sql) |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "prepareStatement", |
| args = {java.lang.String.class} |
| ) |
| public void testPrepareStatement() { |
| PreparedStatement prst = null; |
| Statement st = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| try { |
| String update = "update zoo set family = ? where name = ?;"; |
| prst = conn.prepareStatement(update); |
| prst.setString(1, "cat"); |
| prst.setString(2, "Yasha"); |
| st = conn.createStatement(); |
| st.execute("select * from zoo where family = 'cat'"); |
| rs = st.getResultSet(); |
| assertEquals(0, getCount(rs)); |
| prst.executeUpdate(); |
| st.execute("select * from zoo where family = 'cat'"); |
| rs1 = st.getResultSet(); |
| assertEquals(1, getCount(rs1)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| rs1.close(); |
| prst.close(); |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| prst = conn.prepareStatement(""); |
| prst.execute(); |
| fail("SQLException is not thrown"); |
| } catch (SQLException e) { |
| //ok |
| } |
| |
| try { |
| conn.prepareStatement(null); |
| fail("SQLException is not thrown"); |
| } catch (Exception e) { |
| //ok |
| } |
| |
| |
| } |
| |
| |
| /** |
| * @test { @link java.sql.Connection#prepareStatement(String sql, int |
| * autoGeneratedKeys) } |
| */ |
| // TODO Crashes VM. Fix later. |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Statment.Return_generated_keys/getGeneratedKeys is not supported", |
| method = "prepareStatement", |
| args = {java.lang.String.class, int.class} |
| ) |
| @KnownFailure("not supported") |
| public void testPrepareStatement_String_int() { |
| PreparedStatement prst = null; |
| PreparedStatement prst1 = null; |
| Statement st = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| ResultSet rs4 = null; |
| ResultSet rs5 = null; |
| |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| prst = conn.prepareStatement(insert, |
| Statement.RETURN_GENERATED_KEYS); |
| fail("Fail: prepareStatement does not fail"); |
| } catch (SQLException e) { |
| //ok not supported |
| } |
| |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| |
| prst = conn.prepareStatement(insert, |
| Statement.NO_GENERATED_KEYS); |
| prst.setInt(1, 8); |
| prst.setString(2, "Tuzik"); |
| prst.setString(3, "dog"); |
| st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(2, getCount(rs)); |
| prst.execute(); |
| st.execute("select * from zoo where family = 'dog'"); |
| rs1 = st.getResultSet(); |
| assertEquals(1, getCount(rs1)); |
| // TODO getGeneratedKeys is not supported |
| rs4 = prst.getGeneratedKeys(); |
| assertEquals(0, getCount(rs4)); |
| |
| |
| |
| prst1 = conn.prepareStatement(insert, Statement.RETURN_GENERATED_KEYS); |
| prst1.setInt(1, 5); |
| prst1.setString(2, "Layka"); |
| prst1.setString(3, "dog"); |
| |
| prst1.execute(); |
| |
| |
| |
| rs5 = prst1.getGeneratedKeys(); |
| assertEquals(0, getCount(rs5)); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| rs1.close(); |
| prst.close(); |
| st.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| |
| } |
| |
| /** |
| * @test java.sql.Connection#commit() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "commit", |
| args = {} |
| ) |
| public void testCommit() { |
| Statement st = null; |
| Statement st1 = null; |
| Statement st2 = null; |
| Statement st3 = null; |
| Statement st4 = null; |
| ResultSet rs1 = null; |
| ResultSet rs2 = null; |
| ResultSet rs3 = null; |
| ResultSet rs4 = null; |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| try { |
| conn.commit(); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st3 = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| st3.execute("select * from zoo"); |
| rs3 = st3.getResultSet(); |
| conn.commit(); |
| assertEquals(4, getCount(rs3)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| if (rs3 != null) rs3.close(); |
| if (st3 != null) st3.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException was thrown: " + sqle.toString()); |
| } finally { |
| try { |
| rs1.close(); |
| st.close(); |
| st1.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| |
| } |
| |
| /** |
| * @throws SQLException |
| * @test java.sql.Connection#rollback() |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "rollback", |
| args = {} |
| ) |
| public void testRollback() throws SQLException { |
| Statement st = null; |
| Statement st1 = null; |
| ResultSet rs1 = null; |
| ResultSet rs2 = null; |
| ResultSet rs3 = null; |
| |
| try { |
| conn.setAutoCommit(false); |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| conn.rollback(); |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals("Rollback was ineffective",2, getCount(rs1)); |
| |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| conn.setAutoCommit(true); |
| try { |
| st.close(); |
| st1.close(); |
| rs1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| if (!conn.getAutoCommit()) { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| Statement st2 = null; |
| Statement st3 = null; |
| try { |
| conn.commit(); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| // rollback after commit ineffective |
| conn.rollback(); |
| st3 = conn.createStatement(); |
| st3.execute("select * from zoo"); |
| rs3 = st3.getResultSet(); |
| assertEquals(4, getCount(rs3)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| conn.setAutoCommit(true); |
| try { |
| rs2.close(); |
| rs3.close(); |
| st2.close(); |
| st3.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| } else { |
| fail("Error in test setup: cannot turn autocommit off."); |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| try { |
| st.close(); |
| st1.close(); |
| rs1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| conn.close(); |
| try { |
| conn.rollback(); |
| fail("SQLException expected"); |
| } catch (SQLException e) { |
| // ok |
| } |
| } |
| |
| /** |
| * @test java.sql.Connection#setSavepoint() |
| * |
| * TODO setSavepoint is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setSavepoint", |
| args = {} |
| ) |
| public void testSetSavepoint() { |
| |
| try { |
| conn.setAutoCommit(false); |
| |
| try { |
| Savepoint sp = conn.setSavepoint(); |
| } catch (SQLException e) { |
| // ok not supported |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| |
| |
| //Complete test but: not supported exception is thrown |
| /* |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| if (!conn.getAutoCommit()) { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| Statement st2 = null; |
| ResultSet rs2 = null; |
| try { |
| Savepoint sp = conn.setSavepoint(); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint(); |
| assertNotNull(sp1); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint(); |
| assertNotNull(sp2); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(sp1); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint(); |
| assertNotNull(sp1); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint(); |
| assertNotNull(sp2); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| } else { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| try { |
| Savepoint sp = conn.setSavepoint(); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| try { |
| rs1.close(); |
| st.close(); |
| st1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#setSavepoint(String name) |
| * |
| * TODO setSavepoint is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "setSavepoint", |
| args = {java.lang.String.class} |
| ) |
| public void testSetSavepoint_String() { |
| |
| String testSavepoint = "testSavepoint"; |
| |
| try { |
| conn.setAutoCommit(false); |
| |
| try { |
| Savepoint sp = conn.setSavepoint(testSavepoint); |
| } catch (SQLException e) { |
| // ok not supported |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| |
| /* |
| Statement st = null; |
| Statement st1 = null; |
| ResultSet rs1 = null; |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| if (!conn.getAutoCommit()) { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| Statement st2 = null; |
| ResultSet rs2 = null; |
| try { |
| Savepoint sp = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint("two"); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(sp1); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint("three"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint("four"); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| } else { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| try { |
| Savepoint sp = conn.setSavepoint("five"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| try { |
| rs1.close(); |
| st.close(); |
| st1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#rollback(Savepoint savepoint) |
| * |
| * TODO Savepoint is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "rollback", |
| args = {java.sql.Savepoint.class} |
| ) |
| public void testRollback_Savepoint() { |
| Savepoint sp = new DummySavePoint(); |
| try { |
| conn.setAutoCommit(false); |
| |
| try { |
| conn.rollback(sp); |
| } catch (SQLException e) { |
| //ok |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| /* |
| Statement st = null; |
| Statement st1 = null; |
| ResultSet rs1 = null; |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| if (!conn.getAutoCommit()) { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| Statement st2 = null; |
| ResultSet rs2 = null; |
| try { |
| Savepoint sp = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint("two"); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(sp1); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint("three"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint("four"); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.rollback(); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| } else { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| try { |
| Savepoint sp = conn.setSavepoint("five"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| try { |
| rs1.close(); |
| st.close(); |
| st1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#releaseSavepoint(Savepoint savepoint) |
| * |
| * TODO Savepoint is not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "releaseSavepoint", |
| args = {java.sql.Savepoint.class} |
| ) |
| public void testReleaseSavepoint_Savepoint() { |
| Savepoint sp = new DummySavePoint(); |
| try { |
| conn.setAutoCommit(false); |
| |
| try { |
| conn.releaseSavepoint(sp); |
| } catch (SQLException e) { |
| //ok |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } |
| /* |
| |
| Statement st = null; |
| Statement st1 = null; |
| ResultSet rs1 = null; |
| try { |
| conn.setAutoCommit(false); |
| |
| st = conn.createStatement(); |
| st |
| .execute("insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');"); |
| st |
| .execute("insert into zoo (id, name, family) values (4, 'Orel', 'eagle');"); |
| |
| if (!conn.getAutoCommit()) { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| Statement st2 = null; |
| ResultSet rs2 = null; |
| try { |
| Savepoint sp = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.rollback(sp); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.releaseSavepoint(sp); |
| try { |
| conn.rollback(sp); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| conn.rollback(); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| Savepoint sp1 = conn.setSavepoint("one"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| Savepoint sp2 = conn.setSavepoint("two"); |
| st |
| .execute("insert into zoo (id, name, family) values (6, 'grach', 'rook');"); |
| conn.releaseSavepoint(sp1); |
| try { |
| conn.rollback(sp1); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| conn.commit(); |
| conn.rollback(sp2); |
| st2 = conn.createStatement(); |
| st2.execute("select * from zoo"); |
| rs2 = st2.getResultSet(); |
| assertEquals(4, getCount(rs2)); |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.toString()); |
| } finally { |
| try { |
| rs2.close(); |
| st2.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| } else { |
| st1 = conn.createStatement(); |
| st1.execute("select * from zoo"); |
| rs1 = st1.getResultSet(); |
| assertEquals(4, getCount(rs1)); |
| try { |
| Savepoint sp = conn.setSavepoint("five"); |
| st |
| .execute("insert into zoo (id, name, family) values (5, 'chayka', 'gull');"); |
| conn.releaseSavepoint(sp); |
| fail("SQLException is not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| } catch (SQLException sqle) { |
| fail("SQLException is thrown: " + sqle.toString()); |
| } finally { |
| try { |
| rs1.close(); |
| st.close(); |
| st1.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareStatement(String sql, int[] |
| * columnIndexes) |
| * |
| * TODO prepareStatement(String sql, int[] columnIndexes) is not |
| * supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "prepareStatement", |
| args = {java.lang.String.class, int[].class} |
| ) |
| public void testPrepareStatement_String_intArray() { |
| PreparedStatement prst = null; |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| prst = conn.prepareStatement(insert, new int[] { 0, 1, 2 }); |
| } catch (SQLException e) { |
| //ok not supported |
| } finally { |
| try { |
| prst.close(); |
| } catch (Exception ee) { |
| } |
| } |
| /* |
| |
| Statement st = null; |
| PreparedStatement prst1 = null; |
| PreparedStatement prst = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| ResultSet rs4 = null; |
| ResultSet rs5 = null; |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| prst = conn.prepareStatement(insert, new int[] { 0, 1, 2 }); |
| prst.setInt(1, 8); |
| prst.setString(2, "Tuzik"); |
| prst.setString(3, "dog"); |
| |
| st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(2, getCount(rs)); |
| prst.execute(); |
| st.execute("select * from zoo where family = 'dog'"); |
| rs1 = st.getResultSet(); |
| assertEquals(1, getCount(rs1)); |
| |
| rs4 = prst.getGeneratedKeys(); |
| assertEquals(0, getCount(rs4)); |
| |
| prst1 = conn.prepareStatement(insert, new int[] { 0, 1, 2, 10 }); |
| prst1.setInt(1, 5); |
| prst1.setString(2, "Layka"); |
| prst1.setString(3, "dog"); |
| |
| prst1.execute(); |
| |
| rs5 = prst1.getGeneratedKeys(); |
| assertEquals(0, getCount(rs5)); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| rs1.close(); |
| rs4.close(); |
| rs5.close(); |
| st.close(); |
| prst1.close(); |
| prst.close(); |
| } catch (Exception ee) { |
| } |
| } |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| conn.prepareStatement(insert, new int[] {}); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| conn.prepareStatement(insert, (int[]) null); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } |
| */ |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareStatement(String sql, int resultSetType, |
| * int resultSetConcurrency) |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "not fully supported", |
| method = "prepareStatement", |
| args = {java.lang.String.class, int.class, int.class} |
| ) |
| public void testPrepareStatement_String_int_int() { |
| String query = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| PreparedStatement st = null; |
| ResultSet rs = null; |
| try { |
| |
| st = conn.prepareStatement(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.deleteRow(); |
| fail("Can delete row for READ_ONLY ResultSet"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| if (rs != null) rs.close(); |
| if (st != null) st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| st = conn.prepareStatement(query, ResultSet.TYPE_SCROLL_SENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("bird", (rs.getString(1))); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| try { |
| conn.prepareStatement(query, ResultSet.TYPE_SCROLL_SENSITIVE, -1); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| try { |
| conn.prepareStatement(query, Integer.MIN_VALUE, |
| ResultSet.CONCUR_READ_ONLY); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "not supported options: ResultSet.TYPE_SCROLL_INSENSITIVE," + |
| "ResultSet.CONCUR_UPDATABLE", |
| method = "prepareStatement", |
| args = {java.lang.String.class, int.class, int.class} |
| ) |
| @KnownFailure("not supported") |
| public void testPrepareStatementNotSupported() { |
| String query = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| PreparedStatement st = null; |
| ResultSet rs = null; |
| try { |
| st = conn.prepareStatement(query, |
| ResultSet.TYPE_SCROLL_INSENSITIVE, |
| ResultSet.CONCUR_UPDATABLE); |
| st.execute("select name, family from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.insertRow(); |
| rs.updateObject("family", "bird"); |
| rs.next(); |
| rs.previous(); |
| assertEquals("parrot", (rs.getString(1))); |
| } catch (SQLException sqle) { |
| fail("Got Exception "+sqle.getMessage()); |
| } |
| |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| if (rs != null) rs.close(); |
| if (st != null) st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| |
| } |
| |
| |
| |
| /** |
| * @test java.sql.Connection#prepareStatement(String sql, int resultSetType, |
| * int resultSetConcurrency, int resultSetHoldability) |
| */ |
| // TODO Crashes VM. Fix later. |
| @TestTargetNew( |
| level = TestLevel.SUFFICIENT, |
| notes = "Not fully implemented: ResultSet.CLOSE_CURSORS_AT_COMMIT not supported", |
| method = "prepareStatement", |
| args = {java.lang.String.class, int.class, int.class, int.class} |
| ) |
| public void testPrepareStatement_String_int_int_int() { |
| String query = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| PreparedStatement st = null; |
| ResultSet rs = null; |
| try { |
| st = conn.prepareStatement(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.HOLD_CURSORS_OVER_COMMIT); |
| st.setInt(1, 3); |
| st.setString(2, "Petya"); |
| st.setString(3, "Cock"); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.close(); |
| } catch (SQLException sqle) { |
| fail("Unexpected exception was thrown during closing ResultSet"); |
| } |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| if (rs != null) rs.close(); |
| if (st != null) st.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| /* |
| //TODO ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported |
| try { |
| st = conn.prepareStatement(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, |
| ResultSet.CLOSE_CURSORS_AT_COMMIT); |
| st.execute("select id, name from zoo"); |
| rs = st.getResultSet(); |
| try { |
| rs.close(); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| } catch (SQLException e) { |
| fail("SQLException was thrown: " + e.getMessage()); |
| } finally { |
| try { |
| st.close(); |
| rs.close(); |
| } catch (SQLException ee) { |
| } |
| } |
| */ |
| |
| try { |
| conn.prepareStatement(query, ResultSet.TYPE_FORWARD_ONLY, |
| ResultSet.CONCUR_READ_ONLY, -100); |
| fail("SQLException was not thrown"); |
| } catch (SQLException sqle) { |
| // expected |
| } |
| |
| } |
| |
| /** |
| * @test java.sql.Connection#prepareStatement(String sql, String[] |
| * columnNames) |
| * |
| * TODO prepareStatement(String sql, String[] columnNames) method is |
| * not supported |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "prepareStatement", |
| args = {java.lang.String.class, java.lang.String[].class} |
| ) |
| public void testPrepareStatement_String_StringArray() { |
| PreparedStatement prst = null; |
| PreparedStatement prst1 = null; |
| ResultSet rs = null; |
| ResultSet rs1 = null; |
| ResultSet rs4 = null; |
| ResultSet rs5 = null; |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| conn.prepareStatement(insert, new String[] { "id", "name", |
| "family" }); |
| } catch (SQLException e) { |
| //ok not supported |
| } |
| |
| /* |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| conn.prepareStatement(insert, new String[] {}); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| conn.prepareStatement(insert, (String[]) null); |
| } catch (SQLException e) { |
| fail("SQLException is thrown"); |
| } |
| |
| try { |
| String insert = "insert into zoo (id, name, family) values (?, ?, ?);"; |
| prst = conn.prepareStatement(insert, new String[] { "id", "name", |
| "family" }); |
| prst.setInt(1, 8); |
| prst.setString(2, "Tuzik"); |
| prst.setString(3, "dog"); |
| |
| Statement st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| rs = st.getResultSet(); |
| assertEquals(2, getCount(rs)); |
| prst.execute(); |
| st.execute("select * from zoo where family = 'dog'"); |
| rs1 = st.getResultSet(); |
| assertEquals(1, getCount(rs1)); |
| |
| rs4 = prst.getGeneratedKeys(); |
| assertEquals(0, getCount(rs4)); |
| |
| prst1 = conn.prepareStatement(insert, new String[] { "id", "name", "" }); |
| prst1.setInt(1, 5); |
| prst1.setString(2, "Layka"); |
| prst1.setString(3, "dog"); |
| |
| prst1.execute(); |
| |
| rs5 = prst1.getGeneratedKeys(); |
| assertEquals(0, getCount(rs5)); |
| |
| } catch (SQLException e) { |
| fail("SQLException is thrown: " + e.getMessage()); |
| } finally { |
| try { |
| rs.close(); |
| rs1.close(); |
| rs4.close(); |
| rs5.close(); |
| prst.close(); |
| prst1.close(); |
| } catch (Exception ee) { |
| } |
| } |
| */ |
| |
| |
| } |
| |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported: it should release all resources but it doesn't", |
| method = "close", |
| args = {} |
| ) |
| public void testClose() { |
| try { |
| |
| |
| |
| if (! conn.isClosed()) { |
| conn.close(); |
| } |
| assertTrue(conn.isClosed()); |
| |
| try { |
| conn.prepareCall("select * from zoo"); |
| fail("Should not be able to prepare query closed connection"); |
| } catch (SQLException e) { |
| //ok |
| } |
| } catch (SQLException e) { |
| fail("Error in implementation"); |
| e.printStackTrace(); |
| } |
| |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "not supported", |
| method = "isClosed", |
| args = {} |
| ) |
| public void testIsClosed() throws Exception { |
| |
| assertFalse(conn.isClosed()); |
| conn.close(); |
| assertTrue(conn.isClosed()); |
| |
| conn = DriverManager.getConnection("jdbc:sqlite:/" + dbFile.getPath()); |
| assertFalse(conn.isClosed()); |
| Statement st = conn.createStatement(); |
| st.execute("select * from zoo"); |
| } |
| |
| |
| private static class DummySavePoint implements Savepoint{ |
| |
| public int getSavepointId() { |
| // TODO Auto-generated method stub |
| return 0; |
| } |
| |
| public String getSavepointName() { |
| // TODO Auto-generated method stub |
| return "NoName"; |
| } |
| |
| } |
| } |
