Scrub libcore's SQLite and JDBC tests.

I've moved the tests to the libcore package because they're
maintained by Androids, unlike the tests.* classes maintained
by Apache Harmony.

Change-Id: I23b5ca845517129f426addeabc38e43a8fee4299

1 files changed, 0 insertions, 2807 deletions

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