merge more modules into luni

1 files changed, 2807 insertions, 0 deletions

diff --git a/luni/src/test/java/tests/sql/ConnectionTest.java b/luni/src/test/java/tests/sql/ConnectionTest.java
new file mode 100755
index 0000000..c718108
--- /dev/null
+++ b/luni/src/test/java/tests/sql/ConnectionTest.java
@@ -0,0 +1,2807 @@
+/*
+ * 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";
+        }
+        
+    }
+}