auto import from //depot/cupcake/@135843

89 files changed, 39382 insertions, 0 deletions

diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/AllTests.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/AllTests.java
new file mode 100644
index 0000000..58c670a
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/AllTests.java
@@ -0,0 +1,57 @@
+/*
+ * 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 org.apache.harmony.sql.tests.java.sql;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * This is autogenerated source file. Includes tests for package org.apache.harmony.sql.tests.java.sql;
+ */
+
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(AllTests.suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("All tests for package org.apache.harmony.sql.tests.java.sql;");
+        // $JUnit-BEGIN$
+
+        suite.addTestSuite(BatchUpdateExceptionTest.class);
+        suite.addTestSuite(ConnectionTest.class);
+        suite.addTestSuite(DataTruncationTest.class);
+        suite.addTestSuite(DatabaseMetaDataTest.class);
+        suite.addTestSuite(DateTest.class);
+        suite.addTestSuite(DriverManagerTest.class);
+        suite.addTestSuite(DriverPropertyInfoTest.class);
+        suite.addTestSuite(ParameterMetaDataTest.class);
+        suite.addTestSuite(ResultSetMetaDataTest.class);
+        suite.addTestSuite(ResultSetTest.class);
+        suite.addTestSuite(SQLExceptionTest.class);
+        suite.addTestSuite(SQLPermissionTest.class);
+        suite.addTestSuite(SQLWarningTest.class);
+        suite.addTestSuite(StatementTest.class);
+        suite.addTestSuite(TimeTest.class);
+        suite.addTestSuite(TimestampTest.class);
+        suite.addTestSuite(TypesTest.class);
+
+        // $JUnit-END$
+        return suite;
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/BatchUpdateExceptionTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/BatchUpdateExceptionTest.java
new file mode 100644
index 0000000..87e737e
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/BatchUpdateExceptionTest.java
@@ -0,0 +1,438 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.Serializable;
+import java.sql.BatchUpdateException;
+import java.util.Arrays;
+
+import junit.framework.TestCase;
+
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
+
+@TestTargetClass(BatchUpdateException.class)
+public class BatchUpdateExceptionTest extends TestCase {
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "BatchUpdateException",
+        args = {}
+    )
+    public void testBatchUpdateException() {
+
+        int[] theFinalStates1 = { 0 }; // Error Code state
+        int[][] theFinalStates2 = { null }; // Update Counts array state
+        String[] theFinalStates3 = { null }; // SQL State state value
+        String[] theFinalStates4 = { null }; // Message state
+
+        Exception[] theExceptions = { null };
+
+        BatchUpdateException aBatchUpdateException;
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException();
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testBatchUpdateException
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "BatchUpdateException",
+        args = {int[].class}
+    )
+    public void testBatchUpdateExceptionintArray() {
+
+        int[][] init1 = { { 1, 2, 3 }, null };
+
+        int[] theFinalStates1 = { 0, 0 }; // Error Code state
+        int[][] theFinalStates2 = init1; // Update Counts array state
+        String[] theFinalStates3 = { null, null }; // SQL State state value
+        String[] theFinalStates4 = { null, null }; // Message state
+
+        Exception[] theExceptions = { null, null };
+
+        BatchUpdateException aBatchUpdateException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException(init1[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testBatchUpdateExceptionintArray
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "BatchUpdateException",
+        args = {java.lang.String.class, int[].class}
+    )
+    public void testBatchUpdateExceptionStringintArray() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
+                ".", "a" };
+        int[][] init2 = { { 1, 2, 3 }, {}, { 3 }, null, { 5, 5 }, { 6 },
+                { 121, 2, 1 }, { 1 }, { 1, 2 } };
+
+        int[] theFinalStates1 = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // Error Code
+                                                                // state
+        // Update Counts array state
+        int[][] theFinalStates2 = init2;
+        // SQL State state value
+        String[] theFinalStates3 = { null, null, null, null, null, null, null,
+                null, null };
+        String[] theFinalStates4 = init1; // Message state
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null };
+
+        BatchUpdateException aBatchUpdateException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException(init1[i],
+                        init2[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testBatchUpdateExceptionStringintArray
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "BatchUpdateException",
+        args = {java.lang.String.class, java.lang.String.class, int[].class}
+    )
+    public void testBatchUpdateExceptionStringStringintArray() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
+                ".", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "a", null,
+                "", ".", "a" };
+        int[][] init3 = { { 1, 2, 3 }, {}, { 3 }, { 5, 5 }, { 6 },
+                { 121, 2, 1 }, { 1 }, { 1, 2 }, { 1 }, { 2 }, null };
+
+        int[] theFinalStates1 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; // Error
+                                                                        // Code
+                                                                        // state
+        // Update Counts array state
+        int[][] theFinalStates2 = init3;
+        // SQL State state value
+        String[] theFinalStates3 = init2;
+        String[] theFinalStates4 = init1; // Message state
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null };
+
+        BatchUpdateException aBatchUpdateException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException(init1[i],
+                        init2[i], init3[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testBatchUpdateExceptionStringStringintArray
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "BatchUpdateException",
+        args = {java.lang.String.class, java.lang.String.class, int.class, int[].class}
+    )
+    public void testBatchUpdateExceptionStringStringintintArray() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
+                ".", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "a", null,
+                "", ".", "a" };
+        int[] init3 = { -2147483648, 2147483647, 0, -492417162, -156220255,
+                -173012890, -631026360, -2147483648, -2147483648, -2147483648,
+                -2147483648 };
+        int[][] init4 = { { 1, 2, 3 }, {}, { 3 }, { 5, 5 }, { 6 },
+                { 121, 2, 1 }, { 1 }, { 1, 2 }, { 1 }, { 2 }, null };
+
+        int[] theFinalStates1 = init3; // Error Code state
+        // Update Counts array state
+        int[][] theFinalStates2 = init4;
+        // SQL State state value
+        String[] theFinalStates3 = init2;
+        String[] theFinalStates4 = init1; // Message state
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null };
+
+        BatchUpdateException aBatchUpdateException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException(init1[i],
+                        init2[i], init3[i], init4[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testBatchUpdateExceptionStringStringintintArray
+
+    /*
+     * Method test for getUpdateCounts
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getUpdateCounts",
+        args = {}
+    )
+    public void testGetUpdateCounts() {
+
+        BatchUpdateException aBatchUpdateException;
+        int[][] init1 = { { 1, 2, 3 }, {}, null };
+
+        int[] theReturn;
+        int[][] theReturns = init1;
+
+        int[] theFinalStates1 = { 0, 0, 0 }; // Error Code state
+        int[][] theFinalStates2 = init1; // Update Counts array state
+        String[] theFinalStates3 = { null, null, null }; // SQL State state
+                                                            // value
+        String[] theFinalStates4 = { null, null, null }; // Message state
+
+        Exception[] theExceptions = { null, null, null };
+
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aBatchUpdateException = new BatchUpdateException(init1[i]);
+                theReturn = aBatchUpdateException.getUpdateCounts();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getErrorCode(),
+                        theFinalStates1[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getUpdateCounts(),
+                        theFinalStates2[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getSQLState(), theFinalStates3[i]);
+                assertEquals(i + " Final state mismatch: ",
+                        aBatchUpdateException.getMessage(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetUpdateCounts
+    
+    /**
+     * @tests serialization/deserialization compatibility.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Serialization test",
+        method = "!SerializationSelf",
+        args = {}
+    )
+    public void testSerializationSelf() throws Exception {
+        BatchUpdateException object = new BatchUpdateException();
+        SerializationTest.verifySelf(object, BATCHUPDATEEXCEPTION_COMPARATOR);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Serialization test",
+        method = "!SerializationGolden",
+        args = {}
+    )
+    public void testSerializationCompatibility() throws Exception {
+        int vendorCode = 10;
+        int[] updateCounts = { 1, 2, 3, 4 };
+        BatchUpdateException object = new BatchUpdateException("reason",
+                "SQLState", vendorCode, updateCounts);
+        SerializationTest.verifyGolden(this, object,
+                BATCHUPDATEEXCEPTION_COMPARATOR);
+    }
+
+    // comparator for BatchUpdateException field updateCounts
+    private static final SerializableAssert BATCHUPDATEEXCEPTION_COMPARATOR = new SerializableAssert() {
+        public void assertDeserialized(Serializable initial,
+                Serializable deserialized) {
+
+            // do common checks for all throwable objects
+            SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
+                    deserialized);
+
+            BatchUpdateException initThr = (BatchUpdateException) initial;
+            BatchUpdateException dserThr = (BatchUpdateException) deserialized;
+
+            // verify updateCounts
+            int[] initUpdateCounts = initThr.getUpdateCounts();
+            int[] dserUpdateCounts = dserThr.getUpdateCounts();
+            assertTrue(Arrays.equals(initUpdateCounts, dserUpdateCounts));
+        }
+    };
+
+} // end class BatchUpdateExceptionTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ConnectionTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ConnectionTest.java
new file mode 100644
index 0000000..823c8a5
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ConnectionTest.java
@@ -0,0 +1,101 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.Connection.class)
+public class ConnectionTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("TRANSACTION_SERIALIZABLE", new Integer(8));
+        thePublicStatics.put("TRANSACTION_REPEATABLE_READ", new Integer(4));
+        thePublicStatics.put("TRANSACTION_READ_COMMITTED", new Integer(2));
+        thePublicStatics.put("TRANSACTION_READ_UNCOMMITTED", new Integer(1));
+        thePublicStatics.put("TRANSACTION_NONE", new Integer(0));
+
+        /*
+         * System.out.println( "TRANSACTION_SERIALIZABLE: " +
+         * Connection.TRANSACTION_SERIALIZABLE ); System.out.println(
+         * "TRANSACTION_REPEATABLE_READ: " +
+         * Connection.TRANSACTION_REPEATABLE_READ ); System.out.println(
+         * "TRANSACTION_READ_COMMITTED: " +
+         * Connection.TRANSACTION_READ_COMMITTED ); System.out.println(
+         * "TRANSACTION_READ_UNCOMMITTED: " +
+         * Connection.TRANSACTION_READ_UNCOMMITTED ); System.out.println(
+         * "TRANSACTION_NONE: " + Connection.TRANSACTION_NONE );
+         */
+
+        Class<?> connectionClass;
+        try {
+            connectionClass = Class.forName("java.sql.Connection");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.Connection class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = connectionClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class ConnectionTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DataTruncationTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DataTruncationTest.java
new file mode 100644
index 0000000..bafd679
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DataTruncationTest.java
@@ -0,0 +1,555 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.Serializable;
+import java.sql.DataTruncation;
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(DataTruncation.class)
+public class DataTruncationTest extends TestCase {
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "DataTruncation",
+        args = {int.class, boolean.class, boolean.class, int.class, int.class}
+    )
+    public void testDataTruncationintbooleanbooleanintint() {
+
+        int[] init1 = { -2147483648, 2147483647, 0, 329751502, 318587557,
+                -1217247045, 329474146 };
+        boolean[] init2 = { false, true, false, false, false, true, false };
+        boolean[] init3 = { false, true, false, false, false, false, true };
+        int[] init4 = { -2147483648, 2147483647, 0, 1761409290, -1331044048,
+                -576231606, 661635011 };
+        int[] init5 = { -2147483648, 2147483647, 0, 540816689, -1890783845,
+                -105552912, -85923935 };
+
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        DataTruncation aDataTruncation;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testDataTruncationintbooleanbooleanintint
+
+    /*
+     * Method test for getIndex
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getIndex",
+        args = {}
+    )
+    public void testGetIndex() {
+
+        DataTruncation aDataTruncation;
+        int[] init1 = { -2147483648, 2147483647, 0, -2045829673, 1977156911,
+                478985827, 1687271915 };
+        boolean[] init2 = { false, true, false, false, true, true, true };
+        boolean[] init3 = { false, true, false, false, true, true, true };
+        int[] init4 = { -2147483648, 2147483647, 0, -631377748, 21025030,
+                1215194589, 1064137121 };
+        int[] init5 = { -2147483648, 2147483647, 0, -897998505, 997578180,
+                735015866, 264619424 };
+
+        int theReturn;
+        int[] theReturns = init1;
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                theReturn = aDataTruncation.getIndex();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetIndex
+
+    /*
+     * Method test for getParameter
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getParameter",
+        args = {}
+    )
+    public void testGetParameter() {
+
+        DataTruncation aDataTruncation;
+        int[] init1 = { -2147483648, 2147483647, 0, -492314242, 1637665948,
+                -305785075, 258819883 };
+        boolean[] init2 = { false, true, false, true, true, false, true };
+        boolean[] init3 = { false, true, false, false, false, true, true };
+        int[] init4 = { -2147483648, 2147483647, 0, 1134512579, 533874007,
+                1709608139, 990656593 };
+        int[] init5 = { -2147483648, 2147483647, 0, -1566784226, -744009101,
+                -444614454, 356465980 };
+
+        boolean theReturn;
+        boolean[] theReturns = init2;
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                theReturn = aDataTruncation.getParameter();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetParameter
+
+    /*
+     * Method test for getRead
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getRead",
+        args = {}
+    )
+    public void testGetRead() {
+
+        DataTruncation aDataTruncation;
+        int[] init1 = { -2147483648, 2147483647, 0, 2092420209, -1695764964,
+                1832837995, -80199594 };
+        boolean[] init2 = { false, true, false, false, false, true, true };
+        boolean[] init3 = { false, true, false, false, true, true, false };
+        int[] init4 = { -2147483648, 2147483647, 0, 1762375167, -604897453,
+                1362491587, 1007466498 };
+        int[] init5 = { -2147483648, 2147483647, 0, 1494407222, -1696982311,
+                -940493360, -1777579868 };
+
+        boolean theReturn;
+        boolean[] theReturns = init3;
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                theReturn = aDataTruncation.getRead();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetRead
+
+    /*
+     * Method test for getDataSize
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDataSize",
+        args = {}
+    )
+    public void testGetDataSize() {
+
+        DataTruncation aDataTruncation;
+        int[] init1 = { -2147483648, 2147483647, 0, 1146707040, -2020665632,
+                1268632617, -1595624039 };
+        boolean[] init2 = { false, true, false, true, false, true, true };
+        boolean[] init3 = { false, true, false, true, true, false, false };
+        int[] init4 = { -2147483648, 2147483647, 0, -367493363, 328996907,
+                -1581326731, 835022052 };
+        int[] init5 = { -2147483648, 2147483647, 0, -886134194, 908213800,
+                1123419516, -429606389 };
+
+        int theReturn;
+        int[] theReturns = init4;
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                theReturn = aDataTruncation.getDataSize();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetDataSize
+
+    /*
+     * Method test for getTransferSize
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTransferSize",
+        args = {}
+    )
+    public void testGetTransferSize() {
+
+        DataTruncation aDataTruncation;
+        int[] init1 = { -2147483648, 2147483647, 0, 78096124, 1719192600,
+                -1661234694, -1205825753 };
+        boolean[] init2 = { false, true, false, false, true, false, true };
+        boolean[] init3 = { false, true, false, false, false, false, false };
+        int[] init4 = { -2147483648, 2147483647, 0, -493779295, -2042560243,
+                -217347438, 1357818664 };
+        int[] init5 = { -2147483648, 2147483647, 0, -1647009002, -717544563,
+                -1368171905, -918209633 };
+
+        int theReturn;
+        int[] theReturns = init5;
+        String[] theFinalStates1 = { "01004", "01004", "01004", "01004",
+                "01004", "01004", "01004" };
+        String state2 = "Data truncation";
+        String[] theFinalStates2 = { state2, state2, state2, state2, state2,
+                state2, state2 };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0 };
+        int[] theFinalStates4 = init1;
+        int[] theFinalStates5 = init4;
+        int[] theFinalStates6 = init5;
+        boolean[] theFinalStates7 = init2;
+        boolean[] theFinalStates8 = init3;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aDataTruncation = new DataTruncation(init1[i], init2[i],
+                        init3[i], init4[i], init5[i]);
+                theReturn = aDataTruncation.getTransferSize();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getSQLState(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getMessage(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getIndex(), theFinalStates4[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getDataSize(), theFinalStates5[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getTransferSize(), theFinalStates6[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getParameter(), theFinalStates7[i]);
+                assertEquals(i + "  Final state mismatch", aDataTruncation
+                        .getRead(), theFinalStates8[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetTransferSize
+    
+    /**
+     * @tests serialization/deserialization compatibility.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Serialization test",
+        method = "!SerializationSelf",
+        args = {}
+    )
+    public void testSerializationSelf() throws Exception {
+        DataTruncation object = new DataTruncation(10, true, true, 10, 10);
+        SerializationTest.verifySelf(object, DATATRUNCATION_COMPARATOR);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Serialization test",
+        method = "!SerializationGolden",
+        args = {}
+    )
+    public void testSerializationCompatibility() throws Exception {
+        DataTruncation object = new DataTruncation(10, true, true, 10, 10);
+        SerializationTest.verifyGolden(this, object, DATATRUNCATION_COMPARATOR);
+    }
+
+    // comparator for DataTruncation objects
+    private static final SerializableAssert DATATRUNCATION_COMPARATOR = new SerializableAssert() {
+        public void assertDeserialized(Serializable initial,
+                Serializable deserialized) {
+
+            // do common checks for all throwable objects
+            SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
+                    deserialized);
+
+            DataTruncation initThr = (DataTruncation) initial;
+            DataTruncation dserThr = (DataTruncation) deserialized;
+
+            // verify index
+            assertEquals(initThr.getIndex(), dserThr.getIndex());
+
+            // verify parameter
+            assertEquals(initThr.getParameter(), dserThr.getParameter());
+
+            // verify read
+            assertEquals(initThr.getRead(), dserThr.getRead());
+
+            // verify dataSize
+            assertEquals(initThr.getDataSize(), dserThr.getDataSize());
+
+            // verify transferSize
+            assertEquals(initThr.getTransferSize(), dserThr.getTransferSize());
+        }
+    };
+
+} // end class DataTruncationTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DatabaseMetaDataTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DatabaseMetaDataTest.java
new file mode 100644
index 0000000..5c63c5a
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DatabaseMetaDataTest.java
@@ -0,0 +1,131 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.DatabaseMetaData.class)
+public class DatabaseMetaDataTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Number> thePublicStatics = new HashMap<String, Number>();
+        thePublicStatics.put("sqlStateSQL99", new Integer(2));
+        thePublicStatics.put("sqlStateXOpen", new Integer(1));
+        thePublicStatics.put("attributeNullableUnknown", new Short((short) 2));
+        thePublicStatics.put("attributeNullable", new Short((short) 1));
+        thePublicStatics.put("attributeNoNulls", new Short((short) 0));
+        thePublicStatics.put("tableIndexOther", new Short((short) 3));
+        thePublicStatics.put("tableIndexHashed", new Short((short) 2));
+        thePublicStatics.put("tableIndexClustered", new Short((short) 1));
+        thePublicStatics.put("tableIndexStatistic", new Short((short) 0));
+        thePublicStatics.put("typeSearchable", new Integer(3));
+        thePublicStatics.put("typePredBasic", new Integer(2));
+        thePublicStatics.put("typePredChar", new Integer(1));
+        thePublicStatics.put("typePredNone", new Integer(0));
+        thePublicStatics.put("typeNullableUnknown", new Integer(2));
+        thePublicStatics.put("typeNullable", new Integer(1));
+        thePublicStatics.put("typeNoNulls", new Integer(0));
+        thePublicStatics.put("importedKeyNotDeferrable", new Integer(7));
+        thePublicStatics.put("importedKeyInitiallyImmediate", new Integer(6));
+        thePublicStatics.put("importedKeyInitiallyDeferred", new Integer(5));
+        thePublicStatics.put("importedKeySetDefault", new Integer(4));
+        thePublicStatics.put("importedKeyNoAction", new Integer(3));
+        thePublicStatics.put("importedKeySetNull", new Integer(2));
+        thePublicStatics.put("importedKeyRestrict", new Integer(1));
+        thePublicStatics.put("importedKeyCascade", new Integer(0));
+        thePublicStatics.put("versionColumnPseudo", new Integer(2));
+        thePublicStatics.put("versionColumnNotPseudo", new Integer(1));
+        thePublicStatics.put("versionColumnUnknown", new Integer(0));
+        thePublicStatics.put("bestRowPseudo", new Integer(2));
+        thePublicStatics.put("bestRowNotPseudo", new Integer(1));
+        thePublicStatics.put("bestRowUnknown", new Integer(0));
+        thePublicStatics.put("bestRowSession", new Integer(2));
+        thePublicStatics.put("bestRowTransaction", new Integer(1));
+        thePublicStatics.put("bestRowTemporary", new Integer(0));
+        thePublicStatics.put("columnNullableUnknown", new Integer(2));
+        thePublicStatics.put("columnNullable", new Integer(1));
+        thePublicStatics.put("columnNoNulls", new Integer(0));
+        thePublicStatics.put("procedureNullableUnknown", new Integer(2));
+        thePublicStatics.put("procedureNullable", new Integer(1));
+        thePublicStatics.put("procedureNoNulls", new Integer(0));
+        thePublicStatics.put("procedureColumnResult", new Integer(3));
+        thePublicStatics.put("procedureColumnReturn", new Integer(5));
+        thePublicStatics.put("procedureColumnOut", new Integer(4));
+        thePublicStatics.put("procedureColumnInOut", new Integer(2));
+        thePublicStatics.put("procedureColumnIn", new Integer(1));
+        thePublicStatics.put("procedureColumnUnknown", new Integer(0));
+        thePublicStatics.put("procedureReturnsResult", new Integer(2));
+        thePublicStatics.put("procedureNoResult", new Integer(1));
+        thePublicStatics.put("procedureResultUnknown", new Integer(0));
+
+        Class<?> databaseMetaDataClass;
+        try {
+            databaseMetaDataClass = Class.forName("java.sql.DatabaseMetaData");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.DatabaseMetaData class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = databaseMetaDataClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class DatabaseMetaDataTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DateTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DateTest.java
new file mode 100644
index 0000000..3b833c4
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DateTest.java
@@ -0,0 +1,457 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Date;
+import java.util.Calendar;
+import java.util.TimeZone;
+
+import junit.framework.TestCase;
+@TestTargetClass(Date.class)
+/**
+ * JUnit Testcase for the java.sql.Date class
+ * 
+ */
+public class DateTest extends TestCase {
+
+    // A calendar object created in the GMT time zone
+    static Calendar aCal = Calendar.getInstance(TimeZone.getTimeZone("GMT"));
+
+    // Some interesting millisecond time values
+    // These millisecond times are all in GMT, effectively
+    static long TIME_AN_HOUR = 3600000; // 1000 * 60 * 60 ms
+
+    static long TIME_EPOCH = 0;
+
+    static long TIME_NOW = System.currentTimeMillis();
+
+    static long TIME_NEGATIVE = -3600001;
+
+    static long TIME_TESTDATE1 = getTime(1999, Calendar.DECEMBER, 31, 23, 59,
+            59);
+
+    static long TIME_TESTDATE2 = getTime(2010, Calendar.JUNE, 10, 20, 3, 16);
+
+    static long TIME_TESTDATE3 = getTime(1931, Calendar.APRIL, 21, 1, 25, 1);
+
+    static long TIME_LOWERLIMIT = Long.MIN_VALUE;
+
+    static long TIME_UPPERLIMIT = Long.MAX_VALUE;
+
+    // Date strings
+    static String SQL_DATESTRING1 = "1999-12-31";
+
+    static String SQL_DATESTRING2 = "2010-06-10";
+
+    static String SQL_DATESTRING3 = "1931-04-21";
+
+    static String SQL_EPOCHSTRING = "1970-01-01";
+
+    static String SQL_DATEDAY1 = "1970-01-02";
+
+    static String SQL_NEGATIVE = "1969-12-31";
+
+    static long[] TIME_ARRAY = new long[] { TIME_TESTDATE1, TIME_TESTDATE2,
+            TIME_TESTDATE3, TIME_NEGATIVE, TIME_EPOCH };
+
+    // Date string array for London (GMT)
+    static String[] SQL_DATEARRAY = new String[] { SQL_DATESTRING1,
+            SQL_DATESTRING2, SQL_DATESTRING3, SQL_NEGATIVE, SQL_EPOCHSTRING };
+
+    // Date string array for New York - sometimes a day earlier than London
+    static String[] SQL_NYARRAY = new String[] { "1999-12-31", "2010-06-10",
+            "1931-04-20", "1969-12-31", "1969-12-31" };
+
+    // Date string for Tokyo
+    static String[] SQL_JAPANARRAY = new String[] { "2000-01-01", "2010-06-11",
+            "1931-04-21", "1970-01-01", "1970-01-01" };
+
+    static String[][] SQL_TZ_DATEARRAYS = new String[][] { SQL_DATEARRAY,
+            SQL_NYARRAY, SQL_JAPANARRAY };
+
+    // Timezones
+    static String TZ_LONDON = "Europe/London"; // Note: != GMT
+
+    static String TZ_PACIFIC = "America/Los_Angeles"; // GNT - 8
+
+    static String TZ_JAPAN = "Asia/Tokyo"; // GMT + 9
+
+    static String[] TIMEZONES = { TZ_LONDON, TZ_PACIFIC, TZ_JAPAN };
+
+    /*
+     * Helper method to create a long milliseconds time from a supplied date and
+     * time
+     */
+    static private long getTime(int year, int month, int date, int hour,
+            int minute, int second) {
+        aCal.set(year, month, date, hour, minute, second);
+        return aCal.getTimeInMillis();
+    } // end method getTime( int, int, int, int, int, int )
+
+    /*
+     * Test of the Date(int, int, int) constructor - now deprecated but still
+     * functioning
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "Date",
+        args = {int.class, int.class, int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testDateintintint() {
+
+        int init1[] = { 99, 8099, 9000, 99999, 99, 99, -1, -100 };
+        int init2[] = { 11, 0, 0, 0, 999, 0, 0, -111 };
+        int init3[] = { 31, 0, 0, 0, 0, 999, 0, -999 };
+
+        for (int i = 0; i < init1.length; i++) {
+            Date theDate = new Date(init1[i], init2[i], init3[i]);
+            assertNotNull(theDate);
+        } // end for
+
+    } // end method testDateintintint
+
+    /*
+     * Test of the Date( long ) constructor
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "Date",
+        args = {long.class}
+    )
+    public void testDatelong() {
+
+        long init1[] = { TIME_TESTDATE1, TIME_TESTDATE2, TIME_TESTDATE3,
+                TIME_NEGATIVE, TIME_LOWERLIMIT, TIME_UPPERLIMIT, TIME_EPOCH,
+                TIME_NOW };
+
+        for (long element : init1) {
+            Date theDate = new Date(element);
+            assertNotNull(theDate);
+        } // end for
+
+    } // end method testDatelong
+
+    /*
+     * Test of the (deprecated) int Date.getHours() method - which always throws
+     * an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getHours",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetHours() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.getHours();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+    } // end method testGetHours()
+
+    /*
+     * Test of the (deprecated) int Date.getMinutes() method - which always
+     * throws an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMinutes",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetMinutes() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.getMinutes();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+    } // end method testGetMinutes()
+
+    /*
+     * Test of the (deprecated) int Date.getSeconds() method - which always
+     * throws an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getSeconds",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetSeconds() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.getSeconds();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+    } // end method testGetSeconds()
+
+    /*
+     * Test of the (deprecated) Date.setHours( int ) method - which always
+     * throws an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setHours",
+        args = {int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testSetHours() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.setHours(22);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+    } // end method testSetHours( int )
+
+    /*
+     * Test of the (deprecated) Date.setMinutes( int ) method - which always
+     * throws an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setMinutes",
+        args = {int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testSetMinutes() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.setMinutes(54);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+
+    } // end method testSetMinutes( int )
+
+    /*
+     * Test of the (deprecated) Date.setSeconds( int ) method - which always
+     * throws an IllegalArgumentException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setSeconds",
+        args = {int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testSetSeconds() {
+        Date theDate = new Date(TIME_TESTDATE1);
+        try {
+            theDate.setSeconds(36);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException ie) {
+            //expected
+        } // end try
+    } // end method testSetSeconds( int )
+
+    /*
+     * Test of the String Date.toString() method This method is sensitive to the
+     * time zone setting and this test sets the time zone before calling the
+     * toString() method.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
+    public void testToString() {
+        // This test is set up for GMT time zone, so need to set the time zone
+        // to GMT first
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Date theDate = new Date(TIME_ARRAY[i]);
+            assertEquals(SQL_DATEARRAY[i], theDate.toString());
+        } // end for
+
+    } // end method testToString()
+
+    /*
+     * Test of the void setTime(int) method This does depend on the Time Zone
+     * settings and sets up the time zone to one of a group of specific time
+     * zones and tests the method using each of these time zones in turn.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTime",
+        args = {long.class}
+    )
+    public void testSetTimelong() {
+
+        // Loop over the array of test timezones
+        for (int i = 0; i < TIMEZONES.length; i++) {
+            testSetTimelong(TIMEZONES[i], SQL_TZ_DATEARRAYS[i]);
+        } // end for
+
+    } // end method testSetTimelong()
+
+    /*
+     * Internal method for testing Date.setTime with a specific time zone
+     */
+    private void testSetTimelong(String timeZoneName, String[] dateArray) {
+
+        if (timeZoneName != null) {
+            TimeZone.setDefault(TimeZone.getTimeZone(timeZoneName));
+        } // end if
+
+        Date theDate = new Date(TIME_TESTDATE1);
+
+        // Loop over the array of test times & dates
+        for (int i = 0; i < dateArray.length; i++) {
+            theDate.setTime(TIME_ARRAY[i]);
+            assertEquals(dateArray[i], theDate.toString());
+        } // end for
+
+    } // end method testSetTimelong()
+
+    /*
+     * Test of the Date.valueOf( String ) method This test is not dependent on
+     * the default Time Zone setting
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+    public void testValueOf() {
+        String SQL_NOTVALID1 = "ABCDEF"; // Invalid date string
+        String SQL_NOTVALID2 = "12321.43.56"; // Invalid date string
+        String SQL_NOTVALID3 = null; // Invalid date string
+        String[] SQL_INVALIDARRAY = { SQL_NOTVALID1, SQL_NOTVALID2,
+                SQL_NOTVALID3 };
+
+        Date theDate;
+
+        for (String element : SQL_DATEARRAY) {
+            theDate = Date.valueOf(element);
+            assertEquals(element, theDate.toString());
+        } // end for
+
+        for (String element : SQL_INVALIDARRAY) {
+            try {
+                theDate = Date.valueOf(element);
+                fail("Should throw IllegalArgumentException.");
+            } catch (IllegalArgumentException e) {
+                //expected
+            } // end try
+        } // end for
+
+    } // end method testValueOf()
+    
+    /**
+     * @tests java.sql.Date#valueOf(String )
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+    public void test_valueOf_IllegalArgumentException() {
+        try{
+            Date.valueOf("1996-10-07-01");
+            fail("should throw NumberFormatException");
+        } catch (NumberFormatException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("-10-07-01");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("--01");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("1991--");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("-01-");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("-10-w2-01");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("07-w2-");
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("1997-w2-w2");
+            fail("should throw NumberFormatException");
+        } catch (NumberFormatException e) {
+            //expected
+        }
+        
+        try{
+            Date.valueOf("1996--01");
+            fail("should throw NumberFormatException");
+        } catch (NumberFormatException e) {
+            //expected
+        }
+    }
+
+} // end class DateTest
+
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverManagerTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverManagerTest.java
new file mode 100644
index 0000000..a4b12ab
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverManagerTest.java
@@ -0,0 +1,682 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.BrokenTest;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.PrintWriter;
+import java.lang.reflect.Method;
+import java.security.Permission;
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.sql.SQLPermission;
+import java.util.Enumeration;
+import java.util.Properties;
+
+import junit.framework.TestCase;
+@TestTargetClass(DriverManager.class)
+/**
+ * JUnit Testcase for the java.sql.DriverManager class
+ * 
+ */
+public class DriverManagerTest extends TestCase {
+
+    // Set of driver names to use
+    static final String DRIVER1 = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver1";
+
+    static final String DRIVER2 = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver2";
+
+    static final String DRIVER3 = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver3";
+
+    static final String DRIVER4 = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver4";
+
+    static final String DRIVER5 = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver5";
+
+    static final String INVALIDDRIVER1 = "abc.klm.Foo";
+
+    static String[] driverNames = { DRIVER1, DRIVER2 };
+
+    static int numberLoaded;
+
+    static String baseURL1 = "jdbc:mikes1";
+
+    static String baseURL4 = "jdbc:mikes4";
+
+    static final String JDBC_PROPERTY = "jdbc.drivers";
+
+    static TestHelper_ClassLoader testClassLoader = new TestHelper_ClassLoader();
+
+    // Static initializer to load the drivers so that they are available to all
+    // the
+    // test methods as needed.
+    @Override
+    public void setUp() {
+        numberLoaded = loadDrivers();
+    } // end setUp()
+
+    /**
+     * Test for the method DriverManager.deregisterDriver
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "SQLException checking missed: not feasible.",
+        method = "deregisterDriver",
+        args = {java.sql.Driver.class}
+    )
+    public void testDeregisterDriver() throws Exception {
+        // First get one of the drivers loaded by the test
+        Driver aDriver;
+        aDriver = DriverManager.getDriver(baseURL4);
+
+        // Deregister this driver
+        DriverManager.deregisterDriver(aDriver);
+
+        assertFalse("testDeregisterDriver: Driver was not deregistered.",
+                isDriverLoaded(aDriver));
+
+        // Re-register this driver (so subsequent tests have it available)
+        DriverManager.registerDriver(aDriver);
+        assertTrue("testDeregisterDriver: Driver did not reload.",
+                isDriverLoaded(aDriver));
+
+        // Test deregistering a null driver
+        DriverManager.deregisterDriver(null);
+
+        // Test deregistering a driver which was not loaded by this test's
+        // classloader
+        // TODO - need to load a driver with a different classloader!!
+        aDriver = DriverManager.getDriver(baseURL1);
+
+        try {
+            Class<?> driverClass = Class
+                    .forName(
+                            "org.apache.harmony.sql.tests.java.sql.TestHelper_DriverManager",
+                            true, testClassLoader);
+
+            // Give the Helper class one of our drivers....
+            Class<?>[] methodClasses = {Class.forName("java.sql.Driver")};
+            Method theMethod = driverClass.getDeclaredMethod("setDriver",
+                    methodClasses);
+            Object[] args = {aDriver};
+            assertNotNull(args);
+            theMethod.invoke(null, args);
+        } catch (Exception e) {
+            fail("testDeregisterDriver: Got exception allocating TestHelper: "
+                    + e.getMessage());
+            e.printStackTrace();
+            return;
+        } // end try
+
+        // Check that the driver was not deregistered
+        assertTrue(
+                "testDeregisterDriver: Driver was incorrectly deregistered.",
+                DriverManagerTest.isDriverLoaded(aDriver));
+
+    } // end method testDeregisterDriver()
+
+    static void printClassLoader(Object theObject) {
+        Class<? extends Object> theClass = theObject.getClass();
+        ClassLoader theClassLoader = theClass.getClassLoader();
+        System.out.println("ClassLoader is: " + theClassLoader.toString()
+                + " for object: " + theObject.toString());
+    } // end method printClassLoader( Object )
+
+    static boolean isDriverLoaded(Driver theDriver) {
+        Enumeration<?> driverList = DriverManager.getDrivers();
+        while (driverList.hasMoreElements()) {
+            if ((Driver) driverList.nextElement() == theDriver) {
+                return true;
+            }
+        } // end while
+        return false;
+    } // end method isDriverLoaded( Driver )
+
+    /*
+     * Class under test for Connection getConnection(String)
+     */
+    // valid connection - data1 does not require a user and password...
+    static String validConnectionURL = "jdbc:mikes1:data1";
+
+    // invalid connection - data2 requires a user & password
+    static String invalidConnectionURL1 = "jdbc:mikes1:data2";
+
+    // invalid connection - URL is gibberish
+    static String invalidConnectionURL2 = "xyz1:abc3:456q";
+
+    // invalid connection - URL is null
+    static String invalidConnectionURL3 = null;
+
+    static String[] invalidConnectionURLs = { invalidConnectionURL2,
+            invalidConnectionURL3 };
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getConnection",
+        args = {java.lang.String.class}
+    )
+    public void testGetConnectionString() throws SQLException {
+        Connection theConnection = null;
+        // validConnection - no user & password required
+        theConnection = DriverManager.getConnection(validConnectionURL);
+        assertNotNull(theConnection);
+        assertNotNull(DriverManager.getConnection(invalidConnectionURL1));
+
+        for (String element : invalidConnectionURLs) {
+            try {
+                theConnection = DriverManager
+                        .getConnection(element);
+                fail("Should throw SQLException");
+            } catch (SQLException e) {
+                //expected
+            } // end try
+        } // end for
+    } // end method testGetConnectionString()
+    
+    /**
+     * @tests java.sql.DriverManager#getConnection(String, Properties)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getConnection",
+        args = {java.lang.String.class, java.util.Properties.class}
+    )
+    public void test_getConnection_LStringLProperties() {
+        try {
+            DriverManager.getConnection("fff", //$NON-NLS-1$
+                    new Properties());
+            fail("Should throw SQLException.");
+        } catch (SQLException e) {
+            assertEquals("08001", e.getSQLState()); //$NON-NLS-1$
+        }
+        
+        try {
+            DriverManager.getConnection(null, 
+                    new Properties());
+            fail("Should throw SQLException.");
+        } catch (SQLException e) {
+            assertEquals("08001", e.getSQLState()); //$NON-NLS-1$
+        }
+    }
+
+    /*
+     * Class under test for Connection getConnection(String, Properties)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getConnection",
+        args = {java.lang.String.class, java.util.Properties.class}
+    )
+    public void testGetConnectionStringProperties() throws SQLException {
+        String validURL1 = "jdbc:mikes1:data2";
+        String validuser1 = "theuser";
+        String validpassword1 = "thepassword";
+        String invalidURL1 = "xyz:abc1:foo";
+        String invalidURL2 = "jdbc:mikes1:crazyone";
+        String invalidURL3 = "";
+        String invaliduser1 = "jonny nouser";
+        String invalidpassword1 = "whizz";
+        Properties nullProps = null;
+        Properties validProps = new Properties();
+        validProps.setProperty("user", validuser1);
+        validProps.setProperty("password", validpassword1);
+        Properties invalidProps1 = new Properties();
+        invalidProps1.setProperty("user", invaliduser1);
+        invalidProps1.setProperty("password", invalidpassword1);
+        String[] invalidURLs = { null, invalidURL1,
+                invalidURL2, invalidURL3 };
+        Properties[] invalidProps = { nullProps, invalidProps1};
+        
+        
+
+        Connection theConnection = null;
+        // validConnection - user & password required
+        theConnection = DriverManager.getConnection(validURL1, validProps);
+        assertNotNull(theConnection);
+
+        // invalid Connections
+        for (int i = 0; i < invalidURLs.length; i++) {
+            theConnection = null;
+            try {
+                theConnection = DriverManager.getConnection(invalidURLs[i],
+                        validProps);
+                fail("Should throw SQLException");
+            } catch (SQLException e) {
+                //expected
+            } // end try
+        } // end for
+        for (Properties invalidProp : invalidProps) {
+            assertNotNull(DriverManager.getConnection(validURL1, invalidProp));
+        } 
+    } // end method testGetConnectionStringProperties()
+
+    /*
+     * Class under test for Connection getConnection(String, String, String)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getConnection",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void testGetConnectionStringStringString() throws SQLException {
+        String validURL1 = "jdbc:mikes1:data2";
+        String validuser1 = "theuser";
+        String validpassword1 = "thepassword";
+        String invalidURL1 = "xyz:abc1:foo";
+        String invaliduser1 = "jonny nouser";
+        String invalidpassword1 = "whizz";
+        String[] invalid1 = { null, validuser1, validpassword1 };
+        String[] invalid2 = { validURL1, null, validpassword1 };
+        String[] invalid3 = { validURL1, validuser1, null };
+        String[] invalid4 = { invalidURL1, validuser1, validpassword1 };
+        String[] invalid5 = { validURL1, invaliduser1, invalidpassword1 };
+        String[] invalid6 = { validURL1, validuser1, invalidpassword1 };
+        String[][] invalids1 = { invalid1, invalid4};
+        String[][] invalids2 = {invalid2, invalid3, invalid5, invalid6 };
+
+        Connection theConnection = null;
+        // validConnection - user & password required
+        theConnection = DriverManager.getConnection(validURL1, validuser1,
+                validpassword1);
+        assertNotNull(theConnection);
+        for (String[] theData : invalids1) {
+            theConnection = null;
+            try {
+                theConnection = DriverManager.getConnection(theData[0],
+                        theData[1], theData[2]);
+                fail("Should throw SQLException.");
+            } catch (SQLException e) {
+                //expected
+            } // end try
+        } // end for
+        for (String[] theData : invalids2) {
+            assertNotNull(DriverManager.getConnection(theData[0], theData[1],
+                    theData[2]));
+        } 
+    } // end method testGetConnectionStringStringString()
+
+    static String validURL1 = "jdbc:mikes1";
+
+    static String validURL2 = "jdbc:mikes2";
+
+    static String invalidURL1 = "xyz:acb";
+
+    static String invalidURL2 = null;
+
+    static String[] validURLs = { validURL1, validURL2 };
+
+    static String[] invalidURLs = { invalidURL1, invalidURL2 };
+
+    static String exceptionMsg1 = "No suitable driver";
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDriver",
+        args = {java.lang.String.class}
+    )
+    public void testGetDriver() throws SQLException {
+        for (String element : validURLs) {
+            Driver validDriver = DriverManager.getDriver(element);
+            assertNotNull(validDriver);
+        } // end for
+
+        for (String element : invalidURLs) {
+            try {
+                DriverManager.getDriver(element);
+                fail("Should throw SQLException");
+            } catch (SQLException e) {
+                assertEquals("08001", e.getSQLState());
+                assertEquals(exceptionMsg1, e.getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetDriver()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDrivers",
+        args = {}
+    )
+    public void testGetDrivers() {
+        // Load a driver manager
+        Enumeration<Driver> driverList = DriverManager.getDrivers();
+        int i = 0;
+        while (driverList.hasMoreElements()) {
+            Driver theDriver = driverList.nextElement();
+            assertNotNull(theDriver);
+            i++;
+        } // end while
+
+        // Check that all the drivers are in the list...
+        assertEquals("testGetDrivers: Don't see all the loaded drivers - ", i,
+                numberLoaded);
+    } // end method testGetDrivers()
+
+    static int timeout1 = 25;
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getLoginTimeout",
+        args = {}
+    )
+    public void testGetLoginTimeout() {
+        DriverManager.setLoginTimeout(timeout1);
+        assertEquals(timeout1, DriverManager.getLoginTimeout());
+    } // end method testGetLoginTimeout()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getLogStream",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetLogStream() {
+        assertNull(DriverManager.getLogStream());
+
+        DriverManager.setLogStream(testPrintStream);
+        assertTrue(DriverManager.getLogStream() == testPrintStream);
+
+        DriverManager.setLogStream(null);
+    } // end method testGetLogStream()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getLogWriter",
+        args = {}
+    )
+    public void testGetLogWriter() {
+        assertNull(DriverManager.getLogWriter());
+
+        DriverManager.setLogWriter(testPrintWriter);
+
+        assertTrue(DriverManager.getLogWriter() == testPrintWriter);
+
+        DriverManager.setLogWriter(null);
+    } // end method testGetLogWriter()
+
+    static String testMessage = "DriverManagerTest: test message for print stream";
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "println",
+        args = {java.lang.String.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testPrintln() {
+        // System.out.println("testPrintln");
+        DriverManager.println(testMessage);
+
+        DriverManager.setLogWriter(testPrintWriter);
+        DriverManager.println(testMessage);
+
+        String theOutput = outputStream.toString();
+        // System.out.println("testPrintln: output= " + theOutput );
+        assertTrue(theOutput.startsWith(testMessage));
+
+        DriverManager.setLogWriter(null);
+
+        DriverManager.setLogStream(testPrintStream);
+        DriverManager.println(testMessage);
+
+        theOutput = outputStream2.toString();
+        // System.out.println("testPrintln: output= " + theOutput );
+        assertTrue(theOutput.startsWith(testMessage));
+
+        DriverManager.setLogStream(null);
+    } // end method testPrintln()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking missed: not feasible",
+        method = "registerDriver",
+        args = {java.sql.Driver.class}
+    )
+    public void testRegisterDriver() throws ClassNotFoundException,
+            SQLException, IllegalAccessException, InstantiationException {
+        String EXTRA_DRIVER_NAME = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver3";
+
+        try {
+            DriverManager.registerDriver(null);
+            fail("Should throw NullPointerException.");
+        } catch (NullPointerException e) {
+            // expected
+        } // end try
+
+        Driver theDriver = null;
+        // Load another Driver that isn't in the basic set
+        Class<?> driverClass = Class.forName(EXTRA_DRIVER_NAME);
+        theDriver = (Driver) driverClass.newInstance();
+        DriverManager.registerDriver(theDriver);
+
+        assertTrue("testRegisterDriver: driver not in loaded set",
+                isDriverLoaded(theDriver));
+        
+        
+
+    } // end testRegisterDriver()
+
+    static int validTimeout1 = 15;
+
+    static int validTimeout2 = 0;
+
+    static int[] validTimeouts = { validTimeout1, validTimeout2 };
+
+    static int invalidTimeout1 = -10;
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setLoginTimeout",
+        args = {int.class}
+    )
+    public void testSetLoginTimeout() {
+        for (int element : validTimeouts) {
+            DriverManager.setLoginTimeout(element);
+
+            assertEquals(element, DriverManager.getLoginTimeout());
+        } // end for
+        // Invalid timeouts
+        DriverManager.setLoginTimeout(invalidTimeout1);
+        assertEquals(invalidTimeout1, DriverManager.getLoginTimeout());
+    } // end testSetLoginTimeout()
+
+    static ByteArrayOutputStream outputStream2 = new ByteArrayOutputStream();
+
+    static PrintStream testPrintStream = new PrintStream(outputStream2);
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setLogStream",
+        args = {java.io.PrintStream.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testSetLogStream() {
+        // System.out.println("testSetLogStream");
+        DriverManager.setLogStream(testPrintStream);
+
+        assertSame(testPrintStream, DriverManager.getLogStream());
+
+        DriverManager.setLogStream(null);
+
+        assertNull(DriverManager.getLogStream());
+
+        // Now let's deal with the case where there is a SecurityManager in
+        // place
+        TestSecurityManager theSecManager = new TestSecurityManager();
+        System.setSecurityManager(theSecManager);
+
+        theSecManager.setLogAccess(false);
+
+        try {
+            DriverManager.setLogStream(testPrintStream);
+            fail("Should throw SecurityException.");
+        } catch (SecurityException s) {
+            //expected
+        }
+
+        theSecManager.setLogAccess(true);
+
+        DriverManager.setLogStream(testPrintStream);
+
+        System.setSecurityManager(null);
+    } // end method testSetLogStream()
+
+    static ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+
+    static PrintWriter testPrintWriter = new PrintWriter(outputStream);
+
+    /**
+     * Test for the setLogWriter method
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setLogWriter",
+        args = {java.io.PrintWriter.class}
+    )
+    public void testSetLogWriter() {
+        // System.out.println("testSetLogWriter");
+        DriverManager.setLogWriter(testPrintWriter);
+
+        assertSame(testPrintWriter, DriverManager.getLogWriter());
+
+        DriverManager.setLogWriter(null);
+
+        assertNull("testDriverManager: Log writer not null:", DriverManager
+                .getLogWriter());
+
+        // Now let's deal with the case where there is a SecurityManager in
+        // place
+        TestSecurityManager theSecManager = new TestSecurityManager();
+        System.setSecurityManager(theSecManager);
+
+        theSecManager.setLogAccess(false);
+
+        try {
+            DriverManager.setLogWriter(testPrintWriter);
+            fail("Should throw SecurityException.");
+        } catch (SecurityException s) {
+            //expected
+        }
+
+        theSecManager.setLogAccess(true);
+        DriverManager.setLogWriter(testPrintWriter);
+
+        System.setSecurityManager(null);
+    } // end method testSetLogWriter()
+
+    /*
+     * Method which loads a set of JDBC drivers ready for use by the various
+     * tests @return the number of drivers loaded
+     */
+    static boolean driversLoaded = false;
+
+    private static int loadDrivers() {
+        if (driversLoaded) {
+            return numberLoaded;
+        }
+        /*
+         * First define a value for the System property "jdbc.drivers" - before
+         * the DriverManager class is loaded - this property defines a set of
+         * drivers which the DriverManager will load during its initialization
+         * and which will be loaded on the System ClassLoader - unlike the ones
+         * loaded later by this method which are loaded on the Application
+         * ClassLoader.
+         */
+        int numberLoaded = 0;
+        String theSystemDrivers = DRIVER4 + ":" + DRIVER5 + ":"
+                + INVALIDDRIVER1;
+        System.setProperty(JDBC_PROPERTY, theSystemDrivers);
+        numberLoaded += 2;
+
+        for (String element : driverNames) {
+            try {
+                Class<?> driverClass = Class.forName(element);
+                assertNotNull(driverClass);
+                // System.out.println("Loaded driver - classloader = " +
+                // driverClass.getClassLoader());
+                numberLoaded++;
+            } catch (ClassNotFoundException e) {
+                System.out.println("DriverManagerTest: failed to load Driver: "
+                        + element);
+            } // end try
+        } // end for
+        /*
+         * System.out.println("DriverManagerTest: number of drivers loaded: " +
+         * numberLoaded);
+         */
+        driversLoaded = true;
+        return numberLoaded;
+    } // end method loadDrivers()
+
+    class TestSecurityManager extends SecurityManager {
+
+        boolean logAccess = true;
+
+        SQLPermission sqlPermission = new SQLPermission("setLog");
+
+        RuntimePermission setManagerPermission = new RuntimePermission(
+                "setSecurityManager");
+
+        TestSecurityManager() {
+            super();
+        } // end method TestSecurityManager()
+
+        void setLogAccess(boolean allow) {
+            logAccess = allow;
+        } // end method setLogAccess( boolean )
+
+        @Override
+        public void checkPermission(Permission thePermission) {
+            if (thePermission.equals(sqlPermission)) {
+                if (!logAccess) {
+                    throw new SecurityException("Cannot set the sql Log Writer");
+                } // end if
+                return;
+            } // end if
+
+            if (thePermission.equals(setManagerPermission)) {
+                return;
+            } // end if
+            // super.checkPermission( thePermission );
+        } // end method checkPermission( Permission )
+
+    } // end class TestSecurityManager
+
+} // end class DriverManagerTest
+
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverPropertyInfoTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverPropertyInfoTest.java
new file mode 100644
index 0000000..e442987
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/DriverPropertyInfoTest.java
@@ -0,0 +1,174 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import SQLite.JDBCDriver;
+import dalvik.annotation.BrokenTest;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.SQLException;
+import java.util.Arrays;
+import java.util.Properties;
+
+import junit.framework.TestCase;
+@TestTargetClass(DriverPropertyInfo.class)
+/**
+ * JUnit Testcase for the java.sql.DriverPropertyInfo class
+ * 
+ */
+
+public class DriverPropertyInfoTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.ADDITIONAL,
+        notes = "Empty test",
+        method = "!",
+        args = {}
+    )
+    @BrokenTest("empty")
+    public void testPublicStatics() {
+
+    } // end method testPublicStatics
+
+    /*
+     * Constructor test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verification with invalid parameters missed: no feasible behaviour not specified (black box approach).",
+        method = "DriverPropertyInfo",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    public void testDriverPropertyInfoStringString() {
+
+        DriverPropertyInfo aDriverPropertyInfo = new DriverPropertyInfo(
+                validName, validValue);
+
+        assertNotNull(aDriverPropertyInfo);
+     
+        assertEquals(aDriverPropertyInfo.name,validName);
+        assertEquals(aDriverPropertyInfo.value,validValue);
+
+        aDriverPropertyInfo = new DriverPropertyInfo(null, null);
+
+        assertNotNull(aDriverPropertyInfo);
+        assertNull(aDriverPropertyInfo.name);
+        assertNull(aDriverPropertyInfo.value);
+        
+    } // end method testDriverPropertyInfoStringString
+
+    /*
+     * Public fields test
+     */
+    static String validName = "testname";
+
+    static String validValue = "testvalue";
+
+    static String[] updateChoices = { "Choice1", "Choice2", "Choice3" };
+
+    static String updateValue = "updateValue";
+
+    static boolean updateRequired = true;
+
+    static String updateDescription = "update description";
+
+    static String updateName = "updateName";
+    
+    String connectionURL = "jdbc:sqlite:/" + "Test.db";
+    
+    String classname = "SQLite.JDBCDriver";
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicFields() {
+
+        // Constructor here...
+        DriverPropertyInfo aDriverPropertyInfo = new DriverPropertyInfo(
+                validName, validValue);
+
+        assertTrue(Arrays.equals(testChoices, aDriverPropertyInfo.choices));
+        assertEquals(testValue, aDriverPropertyInfo.value);
+        assertEquals(testRequired, aDriverPropertyInfo.required);
+        assertEquals(testDescription, aDriverPropertyInfo.description);
+        assertEquals(testName, aDriverPropertyInfo.name);
+
+        aDriverPropertyInfo.choices = updateChoices;
+        aDriverPropertyInfo.value = updateValue;
+        aDriverPropertyInfo.required = updateRequired;
+        aDriverPropertyInfo.description = updateDescription;
+        aDriverPropertyInfo.name = updateName;
+
+        assertTrue(Arrays.equals(updateChoices, aDriverPropertyInfo.choices));
+        assertEquals(updateValue, aDriverPropertyInfo.value);
+        assertEquals(updateRequired, aDriverPropertyInfo.required);
+        assertEquals(updateDescription, aDriverPropertyInfo.description);
+        assertEquals(updateName, aDriverPropertyInfo.name);
+        
+      //functional test
+        try {
+            Class.forName(classname).newInstance();
+            Properties props = new Properties();
+            Driver d = DriverManager.getDriver(connectionURL);
+            DriverPropertyInfo[] info = d.getPropertyInfo(connectionURL,
+                    props);
+            // get the property metadata
+            String name = info[0].name;
+            assertNotNull(name);
+            assertEquals(name, "encoding");
+            String[] choices = info[0].choices;
+            assertNull(choices);
+            boolean required = info[0].required;
+            assertFalse(required);
+            String description = info[0].description;
+            assertNull(description);
+
+        } catch (SQLException e) {
+            System.out.println("Error in test setup: " + e.getMessage());
+            e.printStackTrace();
+        } catch (Exception ex) {
+            System.err.println("Unexpected exception " + ex.toString());
+        }
+
+
+    } // end method testPublicFields
+
+    // Default values...
+    static String[] testChoices = null;
+
+    static java.lang.String testValue = validValue;
+
+    static boolean testRequired = false;
+
+    static java.lang.String testDescription = null;
+
+    static java.lang.String testName = validName;
+
+} // end class DriverPropertyInfoTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ParameterMetaDataTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ParameterMetaDataTest.java
new file mode 100644
index 0000000..b488880
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ParameterMetaDataTest.java
@@ -0,0 +1,106 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.ParameterMetaData.class)
+public class ParameterMetaDataTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("parameterModeOut", new Integer(4));
+        thePublicStatics.put("parameterModeInOut", new Integer(2));
+        thePublicStatics.put("parameterModeIn", new Integer(1));
+        thePublicStatics.put("parameterModeUnknown", new Integer(0));
+        thePublicStatics.put("parameterNullableUnknown", new Integer(2));
+        thePublicStatics.put("parameterNullable", new Integer(1));
+        thePublicStatics.put("parameterNoNulls", new Integer(0));
+
+        /*
+         * System.out.println( "parameterModeOut: " +
+         * ParameterMetaData.parameterModeOut ); System.out.println(
+         * "parameterModeInOut: " + ParameterMetaData.parameterModeInOut );
+         * System.out.println( "parameterModeIn: " +
+         * ParameterMetaData.parameterModeIn ); System.out.println(
+         * "parameterModeUnknown: " + ParameterMetaData.parameterModeUnknown );
+         * System.out.println( "parameterNullableUnknown: " +
+         * ParameterMetaData.parameterNullableUnknown ); System.out.println(
+         * "parameterNullable: " + ParameterMetaData.parameterNullable );
+         * System.out.println( "parameterNoNulls: " +
+         * ParameterMetaData.parameterNoNulls );
+         */
+
+        Class<?> parameterMetaDataClass;
+        try {
+            parameterMetaDataClass = Class
+                    .forName("java.sql.ParameterMetaData");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.ParameterMetaData class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = parameterMetaDataClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class ParameterMetaDataTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetMetaDataTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetMetaDataTest.java
new file mode 100644
index 0000000..dc28c4c
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetMetaDataTest.java
@@ -0,0 +1,96 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.ResultSetMetaData.class)
+public class ResultSetMetaDataTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("columnNullableUnknown", new Integer(2));
+        thePublicStatics.put("columnNullable", new Integer(1));
+        thePublicStatics.put("columnNoNulls", new Integer(0));
+
+        /*
+         * System.out.println( "columnNullableUnknown: " +
+         * ResultSetMetaData.columnNullableUnknown ); System.out.println(
+         * "columnNullable: " + ResultSetMetaData.columnNullable );
+         * System.out.println( "columnNoNulls: " +
+         * ResultSetMetaData.columnNoNulls );
+         */
+
+        Class<?> resultSetMetaDataClass;
+        try {
+            resultSetMetaDataClass = Class
+                    .forName("java.sql.ResultSetMetaData");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.ResultSetMetaData class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = resultSetMetaDataClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class ResultSetMetaDataTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetTest.java
new file mode 100644
index 0000000..bd9b18f
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/ResultSetTest.java
@@ -0,0 +1,113 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.ResultSet.class)
+public class ResultSetTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("CLOSE_CURSORS_AT_COMMIT",
+                new java.lang.Integer(2));
+        thePublicStatics.put("HOLD_CURSORS_OVER_COMMIT", new java.lang.Integer(
+                1));
+        thePublicStatics.put("CONCUR_UPDATABLE", new java.lang.Integer(1008));
+        thePublicStatics.put("CONCUR_READ_ONLY", new java.lang.Integer(1007));
+        thePublicStatics.put("TYPE_SCROLL_SENSITIVE", new java.lang.Integer(
+                1005));
+        thePublicStatics.put("TYPE_SCROLL_INSENSITIVE", new java.lang.Integer(
+                1004));
+        thePublicStatics.put("TYPE_FORWARD_ONLY", new java.lang.Integer(1003));
+        thePublicStatics.put("FETCH_UNKNOWN", new java.lang.Integer(1002));
+        thePublicStatics.put("FETCH_REVERSE", new java.lang.Integer(1001));
+        thePublicStatics.put("FETCH_FORWARD", new java.lang.Integer(1000));
+
+        /*
+         * System.out.println( "CLOSE_CURSORS_AT_COMMIT: " +
+         * ResultSet.CLOSE_CURSORS_AT_COMMIT ); System.out.println(
+         * "HOLD_CURSORS_OVER_COMMIT: " + ResultSet.HOLD_CURSORS_OVER_COMMIT );
+         * System.out.println( "CONCUR_UPDATABLE: " + ResultSet.CONCUR_UPDATABLE );
+         * System.out.println( "CONCUR_READ_ONLY: " + ResultSet.CONCUR_READ_ONLY );
+         * System.out.println( "TYPE_SCROLL_SENSITIVE: " +
+         * ResultSet.TYPE_SCROLL_SENSITIVE ); System.out.println(
+         * "TYPE_SCROLL_INSENSITIVE: " + ResultSet.TYPE_SCROLL_INSENSITIVE );
+         * System.out.println( "TYPE_FORWARD_ONLY: " +
+         * ResultSet.TYPE_FORWARD_ONLY ); System.out.println( "FETCH_UNKNOWN: " +
+         * ResultSet.FETCH_UNKNOWN ); System.out.println( "FETCH_REVERSE: " +
+         * ResultSet.FETCH_REVERSE ); System.out.println( "FETCH_FORWARD: " +
+         * ResultSet.FETCH_FORWARD );
+         */
+
+        Class<?> resultSetClass;
+        try {
+            resultSetClass = Class.forName("java.sql.ResultSet");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.ResultSet class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = resultSetClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class ResultSetTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLExceptionTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLExceptionTest.java
new file mode 100644
index 0000000..53a8a71
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLExceptionTest.java
@@ -0,0 +1,619 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.Serializable;
+import java.lang.reflect.Field;
+import java.sql.SQLException;
+
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
+
+import junit.framework.Assert;
+import junit.framework.TestCase;
+
+@TestTargetClass(SQLException.class)
+public class SQLExceptionTest extends TestCase {
+
+    static long theFixedSUID = 2135244094396331484L;
+
+    /*
+     * SUID test
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testSUID() {
+
+        try {
+            Class<?> theClass = Class.forName("java.sql.SQLException");
+            Field theField = theClass.getDeclaredField("serialVersionUID");
+            theField.setAccessible(true);
+            long theSUID = theField.getLong(null);
+            assertEquals("SUID mismatch: ", theFixedSUID, theSUID);
+        } catch (Exception e) {
+            System.out.println("SUID check got exception: " + e.getMessage());
+            // assertTrue("Exception while testing SUID ", false );
+        } // end catch
+
+    } // end method testSUID
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLException",
+        args = {java.lang.String.class, java.lang.String.class, int.class}
+    )
+    public void testSQLExceptionStringStringint() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", "1", "a",
+                null, "", "\u0000", "a", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "a",
+                "&valid*", "a", "a", "a", null, "", "\u0000" };
+        int[] init3 = { -2147483648, 2147483647, 0, 48429456, 1770127344,
+                1047282235, -545472907, -2147483648, -2147483648, -2147483648,
+                -2147483648, -2147483648, -2147483648 };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLException[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null, null, null, null, null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null, null, null };
+
+        SQLException aSQLException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i], init3[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLExceptionStringStringint
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLException",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    public void testSQLExceptionStringString() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
+                "\u0000", "a", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "a", "a",
+                "a", null, "", "\u0000" };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0,
+                0, 0, 0, 0, 0, 0 };
+        SQLException[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null, null, null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null };
+
+        SQLException aSQLException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLExceptionStringString
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLException",
+        args = {java.lang.String.class}
+    )
+    public void testSQLExceptionString() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, 
+                "", "\u0000" };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = { null, null, null, null, null, null, null,
+                null };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0,
+                0, 0, 0 };
+        SQLException[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null };
+
+        SQLException aSQLException;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLExceptionString
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLException",
+        args = {}
+    )
+    public void testSQLException() {
+
+        String[] theFinalStates1 = { null };
+        String[] theFinalStates2 = { null };
+        int[] theFinalStates3 = { 0 };
+        SQLException[] theFinalStates4 = { null };
+
+        Exception[] theExceptions = { null };
+
+        SQLException aSQLException;
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException();
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLException
+
+    /*
+     * Method test for getErrorCode
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getErrorCode",
+        args = {}
+    )
+    public void testGetErrorCode() {
+
+        SQLException aSQLException;
+        String[] init1 = { "a", "1", "valid1", "----", null, "&valid*", "1" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", null, "a" };
+        int[] init3 = { -2147483648, 2147483647, 0, 48429456, 1770127344,
+                1047282235, -545472907 };
+
+        int theReturn;
+        int[] theReturns = init3;
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLException[] theFinalStates4 = { null, null, null, null, null, null,
+                null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i], init3[i]);
+                theReturn = aSQLException.getErrorCode();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetErrorCode
+
+    /*
+     * Method test for getNextException
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getNextException",
+        args = {}
+    )
+    public void testGetNextException() {
+
+        SQLException aSQLException;
+        String[] init1 = { "a", "1", "valid1", "----", null, "&valid*", "1" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", null, "a" };
+        int[] init3 = { -2147483648, 2147483647, 0, 48429456, 1770127344,
+                1047282235, -545472907 };
+        SQLException[] init4 = { new SQLException(), null, new SQLException(),
+                new SQLException(), new SQLException(), null,
+                new SQLException() };
+
+        SQLException theReturn;
+        SQLException[] theReturns = init4;
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLException[] theFinalStates4 = init4;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i], init3[i]);
+                aSQLException.setNextException(init4[i]);
+                theReturn = aSQLException.getNextException();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetNextException
+
+    /*
+     * Method test for getSQLState
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getSQLState",
+        args = {}
+    )
+    public void testGetSQLState() {
+
+        SQLException aSQLException;
+        String[] init1 = { "a", "1", "valid1", "----", null, "&valid*", "1" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", null, "a" };
+        int[] init3 = { -2147483648, 2147483647, 0, 48429456, 1770127344,
+                1047282235, -545472907 };
+
+        String theReturn;
+        String[] theReturns = init2;
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLException[] theFinalStates4 = { null, null, null, null, null, null,
+                null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i], init3[i]);
+                theReturn = aSQLException.getSQLState();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetSQLState
+
+    /*
+     * Method test for setNextException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "setNextException",
+        args = {java.sql.SQLException.class}
+    )
+    public void testSetNextExceptionSQLException() {
+
+        SQLException[] parm1 = { new SQLException(), null, new SQLException(),
+                new SQLException(), new SQLException(), null,
+                new SQLException() };
+
+        SQLException aSQLException;
+
+        String[] init1 = { "a", "1", "valid1", "----", null, "&valid*", "1" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", null, "a" };
+        int[] init3 = { -2147483648, 2147483647, 0, 48429456, 1770127344,
+                1047282235, -545472907 };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLException[] theFinalStates4 = parm1;
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null };
+
+        int loopCount = parm1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLException = new SQLException(init1[i], init2[i], init3[i]);
+                aSQLException.setNextException(parm1[i]);
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLException
+                        .getNextException(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSetNextExceptionSQLException
+
+    /**
+     * @tests serialization/deserialization compatibility.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Serialization test",
+        method = "!SerializationSelf",
+        args = {}
+    )
+    public void testSerializationSelf() throws Exception {
+        SQLException object = new SQLException();
+        SerializationTest.verifySelf(object, SQLEXCEPTION_COMPARATOR);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Serialization test",
+        method = "!SerializationGolden",
+        args = {}
+    )
+    public void testSerializationCompatibility() throws Exception {
+
+        SQLException nextSQLException = new SQLException("nextReason",
+                "nextSQLState", 33);
+
+        int vendorCode = 10;
+        SQLException object = new SQLException("reason", "SQLState", vendorCode);
+
+        object.setNextException(nextSQLException);
+
+        SerializationTest.verifyGolden(this, object, SQLEXCEPTION_COMPARATOR);
+    }
+
+    // comparator for SQLException objects
+    private static final SerializableAssert SQLEXCEPTION_COMPARATOR = new SerializableAssert() {
+        public void assertDeserialized(Serializable initial,
+                Serializable deserialized) {
+
+            // do common checks for all throwable objects
+            SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
+                    deserialized);
+
+            SQLException initThr = (SQLException) initial;
+            SQLException dserThr = (SQLException) deserialized;
+
+            // verify SQLState
+            Assert.assertEquals("SQLState", initThr.getSQLState(), dserThr
+                    .getSQLState());
+
+            // verify vendorCode
+            Assert.assertEquals("vendorCode", initThr.getErrorCode(), dserThr
+                    .getErrorCode());
+
+            // verify next
+            if (initThr.getNextException() == null) {
+                assertNull(dserThr.getNextException());
+            } else {
+                // use the same comparator
+                SQLEXCEPTION_COMPARATOR.assertDeserialized(initThr
+                        .getNextException(), dserThr.getNextException());
+            }
+        }
+    };
+    
+    /**
+     * @tests java.sql.SQLException#setNextException(java.sql.SQLException)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "setNextException",
+        args = {java.sql.SQLException.class}
+    )
+    public void test_setNextException_LSQLException() {
+        SQLException se1 = new SQLException("reason" , "SQLState" , 1);
+        SQLException se2 = new SQLException("reason" , "SQLState" , 2);
+        SQLException se3 = new SQLException("reason" , "SQLState" , 3);
+        SQLException se4 = new SQLException("reason" , "SQLState" , 4);
+        
+        se1.setNextException(se2);
+        assertSame(se2, se1.getNextException());
+        
+        se1.setNextException(se3);
+        assertSame(se2, se1.getNextException());
+        assertSame(se3, se2.getNextException());
+        assertNull(se3.getNextException());
+        
+        se3.setNextException(null);
+        assertNull(se3.getNextException());
+        
+        se3.setNextException(se4);
+        assertSame(se4, se3.getNextException());
+    }
+
+} // end class SQLExceptionTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLPermissionTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLPermissionTest.java
new file mode 100644
index 0000000..5122478
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLPermissionTest.java
@@ -0,0 +1,91 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.SQLPermission;
+
+import junit.framework.TestCase;
+@TestTargetClass(SQLPermission.class)
+/**
+ * JUnit Testcase for the java.sql.SQLPermission class
+ * 
+ * Note that the SQLPermission class only defines 2 constructors and all other
+ * methods are inherited. This testcase explicitly tets the constructors but also
+ * implicitly tests some of the inherited query methods.
+ * 
+ */
+
+public class SQLPermissionTest extends TestCase {
+
+    /*
+     * Constructor test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "invalid parameters checking missed. not fully supported",
+        method = "SQLPermission",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    public void testSQLPermissionStringString() {
+        String validName = "setLog";
+        String validActions = "theActions";
+
+        SQLPermission thePermission = new SQLPermission(validName, validActions);
+
+        assertNotNull(thePermission);
+        assertEquals(validName, thePermission.getName());
+        // System.out.println("The actions: " + thePermission.getActions() + "."
+        // );
+        assertEquals("", thePermission.getActions());
+    } // end method testSQLPermissionStringString
+
+    /*
+     * Constructor test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not fully supported",
+        method = "SQLPermission",
+        args = {java.lang.String.class}
+    )
+    public void testSQLPermissionString() {
+        String validName = "setLog";
+
+        SQLPermission thePermission = new SQLPermission(validName);
+
+        assertNotNull(thePermission);
+        assertEquals(validName, thePermission.getName());
+
+        // Set an invalid name ... 
+        String invalidName = "foo";
+
+        thePermission = new SQLPermission(invalidName);
+
+        assertNotNull(thePermission);
+        assertEquals(invalidName, thePermission.getName());
+        assertEquals("", thePermission.getActions());
+    } // end method testSQLPermissionString
+
+} // end class SQLPermissionTest
+
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLWarningTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLWarningTest.java
new file mode 100644
index 0000000..2307f8e
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/SQLWarningTest.java
@@ -0,0 +1,474 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.Serializable;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import org.apache.harmony.testframework.serialization.SerializationTest.SerializableAssert;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(SQLWarning.class)
+public class SQLWarningTest extends TestCase {
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "SQLWarning",
+        args = {}
+    )
+    public void testSQLWarning() {
+
+        String[] theFinalStates1 = { null };
+        String[] theFinalStates2 = { null };
+        int[] theFinalStates3 = { 0 };
+        SQLWarning[] theFinalStates4 = { null };
+
+        Exception[] theExceptions = { null };
+
+        SQLWarning aSQLWarning;
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning();
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLWarning
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLWarning",
+        args = {java.lang.String.class}
+    )
+    public void testSQLWarningString() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, 
+                "", "\u0000" };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = { null, null, null, null, null, null, null,
+                null };
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0, 0 };
+        SQLWarning[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null };
+
+        SQLWarning aSQLWarning;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning(init1[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLWarningString
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SQLWarning",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    public void testSQLWarningStringString() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
+                "\u0000", "a", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "a", "a",
+                "a", null, "", "\u0000" };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
+        SQLWarning[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null, null, null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null };
+
+        SQLWarning aSQLWarning;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning(init1[i], init2[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLWarningStringString
+
+    /*
+     * ConstructorTest
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "SQLWarning",
+        args = {java.lang.String.class, java.lang.String.class, int.class}
+    )
+    public void testSQLWarningStringStringint() {
+
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*", "----",
+                "----", null, "", "\u0000", "a", "a", "a" };
+        String[] init2 = { "a", "1", "valid1", "----", "&valid*", "valid1",
+                "----", "a", "a", "a", null, "", "\u0000" };
+        int[] init3 = { -2147483648, 2147483647, 0, 1412862821, -733923487,
+                488067774, -1529953616, -2147483648, -2147483648, -2147483648,
+                -2147483648, -2147483648, -2147483648 };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = init2;
+        int[] theFinalStates3 = init3;
+        SQLWarning[] theFinalStates4 = { null, null, null, null, null, null,
+                null, null, null, null, null, null, null };
+
+        Exception[] theExceptions = { null, null, null, null, null, null, null,
+                null, null, null, null, null, null };
+
+        SQLWarning aSQLWarning;
+        int loopCount = init1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning(init1[i], init2[i], init3[i]);
+                if (theExceptions[i] != null) {
+                    fail();
+                }
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSQLWarningStringStringint
+
+    /*
+     * Method test for getNextWarning
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getNextWarning",
+        args = {}
+    )
+    public void testGetNextWarning() {
+
+        SQLWarning aSQLWarning;
+        String[] init1 = { "a", "1", "valid1", "----", "&valid*" };
+
+        SQLWarning theReturn;
+        SQLWarning[] theReturns = { null };
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = { null };
+        int[] theFinalStates3 = { 0 };
+        SQLWarning[] theFinalStates4 = { null };
+
+        Exception[] theExceptions = { null };
+
+        int loopCount = 1;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning(init1[i]);
+                theReturn = aSQLWarning.getNextWarning();
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "Return value mismatch", theReturn,
+                        theReturns[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testGetNextWarning
+
+    /*
+     * Method test for setNextWarning
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "setNextWarning",
+            args = {java.sql.SQLWarning.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "getNextWarning",
+            args = {}
+        )
+    })
+    public void testSetNextWarningSQLWarning() {
+
+        SQLWarning[] parm1 = { new SQLWarning(), null };
+
+        SQLWarning aSQLWarning;
+        String[] init1 = { "a", "1" };
+
+        String[] theFinalStates1 = init1;
+        String[] theFinalStates2 = { null, null };
+        int[] theFinalStates3 = { 0, 0 };
+        SQLWarning[] theFinalStates4 = parm1;
+
+        Exception[] theExceptions = { null, null };
+
+        int loopCount = parm1.length;
+        for (int i = 0; i < loopCount; i++) {
+            try {
+                aSQLWarning = new SQLWarning(init1[i]);
+                aSQLWarning.setNextWarning(parm1[i]);
+                if (theExceptions[i] != null) {
+                    fail(i + "Exception missed");
+                }
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getMessage(), theFinalStates1[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getSQLState(), theFinalStates2[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getErrorCode(), theFinalStates3[i]);
+                assertEquals(i + "  Final state mismatch", aSQLWarning
+                        .getNextWarning(), theFinalStates4[i]);
+
+            } catch (Exception e) {
+                if (theExceptions[i] == null) {
+                    fail(i + "Unexpected exception");
+                }
+                assertEquals(i + "Exception mismatch", e.getClass(),
+                        theExceptions[i].getClass());
+                assertEquals(i + "Exception mismatch", e.getMessage(),
+                        theExceptions[i].getMessage());
+            } // end try
+        } // end for
+
+    } // end method testSetNextWarningSQLWarning
+       
+    /**
+     * @tests java.sql.SQLWarning#setNextWarning(java.sql.SQLWarning)
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "setNextWarning",
+            args = {java.sql.SQLWarning.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "getNextWarning",
+            args = {}
+        )
+    })
+    public void test_setNextWarning_SQLWarning() {
+        SQLWarning sw = new SQLWarning("reason", "SQLState", 0);
+        SQLWarning sw1 = new SQLWarning("reason", "SQLState", 1);
+        SQLWarning sw2 = new SQLWarning("reason", "SQLState", 2);
+        SQLWarning sw3 = new SQLWarning("reason", "SQLState", 3);
+        
+        SQLException se = new SQLException("reason", "SQLState", 4);
+        
+        sw.setNextWarning(sw1);
+        assertSame(sw1, sw.getNextException());
+        assertSame(sw1, sw.getNextWarning());
+        
+        
+        sw.setNextWarning(sw2);
+        assertSame(sw2, sw1.getNextException());
+        assertSame(sw2, sw1.getNextWarning());
+        
+        sw.setNextException(sw3);
+        assertSame(sw3, sw2.getNextException());
+        assertSame(sw3, sw2.getNextWarning());
+        
+        sw.setNextException(se);
+        assertSame(se, sw3.getNextException());
+        try {
+            sw3.getNextWarning();
+            fail("should throw Error");
+        } catch (Error e) {
+            //expected
+        }
+    }
+    
+    /**
+     * @tests serialization/deserialization compatibility.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Serialization test",
+        method = "SQLWarning",
+        args = {}
+    )
+    public void testSerializationSelf() throws Exception {
+        SQLWarning object = new SQLWarning();
+        SerializationTest.verifySelf(object, SQLWARNING_COMPARATOR);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Serialization test",
+        method = "SQLWarning",
+        args = {java.lang.String.class, java.lang.String.class, int.class}
+    )
+    public void testSerializationCompatibility() throws Exception {
+        SQLWarning object = new SQLWarning();
+        
+        SQLWarning nextSQLWarning = new SQLWarning("nextReason",
+                "nextSQLState", 10);
+      
+        object.setNextWarning(nextSQLWarning);
+
+        SerializationTest.verifyGolden(this, object, SQLWARNING_COMPARATOR);
+    }
+
+    // comparator for SQLWarning objects
+    private static final SerializableAssert SQLWARNING_COMPARATOR = new SerializableAssert() {
+        public void assertDeserialized(Serializable initial,
+                Serializable deserialized) {
+
+            // do common checks for all throwable objects
+            SerializationTest.THROWABLE_COMPARATOR.assertDeserialized(initial,
+                    deserialized);
+
+            SQLWarning initThr = (SQLWarning) initial;
+            SQLWarning dserThr = (SQLWarning) deserialized;
+
+            // verify getNextWarning() method
+            if (initThr.getNextWarning() == null) {
+                assertNull(dserThr.getNextWarning());
+            } else {
+                // use the same comparator
+                SQLWARNING_COMPARATOR.assertDeserialized(initThr
+                        .getNextWarning(), dserThr.getNextWarning());
+            }
+        }
+    };
+
+} // end class SQLWarningTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/StatementTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/StatementTest.java
new file mode 100644
index 0000000..fb3e550
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/StatementTest.java
@@ -0,0 +1,104 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.Statement.class)
+public class StatementTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("NO_GENERATED_KEYS", new Integer(2));
+        thePublicStatics.put("RETURN_GENERATED_KEYS", new Integer(1));
+        thePublicStatics.put("EXECUTE_FAILED", new Integer(-3));
+        thePublicStatics.put("SUCCESS_NO_INFO", new Integer(-2));
+        thePublicStatics.put("CLOSE_ALL_RESULTS", new Integer(3));
+        thePublicStatics.put("KEEP_CURRENT_RESULT", new Integer(2));
+        thePublicStatics.put("CLOSE_CURRENT_RESULT", new Integer(1));
+
+        /*
+         * System.out.println( "NO_GENERATED_KEYS: " +
+         * Statement.NO_GENERATED_KEYS ); System.out.println(
+         * "RETURN_GENERATED_KEYS: " + Statement.RETURN_GENERATED_KEYS );
+         * System.out.println( "EXECUTE_FAILED: " + Statement.EXECUTE_FAILED );
+         * System.out.println( "SUCCESS_NO_INFO: " + Statement.SUCCESS_NO_INFO );
+         * System.out.println( "CLOSE_ALL_RESULTS: " +
+         * Statement.CLOSE_ALL_RESULTS ); System.out.println(
+         * "KEEP_CURRENT_RESULT: " + Statement.KEEP_CURRENT_RESULT );
+         * System.out.println( "CLOSE_CURRENT_RESULT: " +
+         * Statement.CLOSE_CURRENT_RESULT );
+         */
+
+        Class<?> statementClass;
+        try {
+            statementClass = Class.forName("java.sql.Statement");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.Statement class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = statementClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class StatementTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_ClassLoader.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_ClassLoader.java
new file mode 100644
index 0000000..940a3aa
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_ClassLoader.java
@@ -0,0 +1,219 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class TestHelper_ClassLoader extends ClassLoader {
+
+    public TestHelper_ClassLoader() {
+        super(null);
+    }
+
+    /**
+     * Loads a class specified by its name
+     * <p>
+     * This classloader makes the assumption that any class it is asked to load
+     * is in the current directory....
+     */
+    @Override
+    public Class<?> findClass(String className) throws ClassNotFoundException {
+        Class<?> theClass = null;
+
+        if (!className.equals("org.apache.harmony.sql.tests.java.sql.TestHelper_DriverManager")) {
+            return null;
+        }
+
+        String classNameAsFile = className.replace('.', '/') + ".class";
+        // System.out.println("findClass - class filename = " + classNameAsFile
+        // );
+
+        String classPath = System.getProperty("java.class.path");
+        // System.out.println("Test class loader - classpath = " + classPath );
+
+        String theSeparator = String.valueOf(File.pathSeparatorChar);
+        String[] theClassPaths = classPath.split(theSeparator);
+        for (int i = 0; (i < theClassPaths.length) && (theClass == null); i++) {
+            // Ignore jar files...
+            if (theClassPaths[i].endsWith(".jar")) {
+                theClass = loadClassFromJar(theClassPaths[i], className,
+                        classNameAsFile);
+            } else {
+                theClass = loadClassFromFile(theClassPaths[i], className,
+                        classNameAsFile);
+            } // end if
+        } // end for
+
+        return theClass;
+    } // end method findClass( String )
+
+    @Override
+    public Class<?> loadClass(String className) throws ClassNotFoundException {
+        // Allowed classes:
+        String[] disallowedClasses = { "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver1",
+                "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver2",
+                "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver4",
+                "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver5" };
+
+        Class<?> theClass;
+
+        theClass = findLoadedClass(className);
+        if (theClass != null) {
+            return theClass;
+        }
+
+        theClass = this.findClass(className);
+
+        if (theClass == null) {
+            for (String element : disallowedClasses) {
+                if (element.equals(className)) {
+                    return null;
+                } // end if
+            } // end for
+            theClass = Class.forName(className);
+        } // end if
+
+        return theClass;
+    } // end method loadClass( String )
+
+    private Class<?> loadClassFromFile(String pathName, String className,
+            String classNameAsFile) {
+        Class<?> theClass = null;
+        FileInputStream theInput = null;
+        File theFile = null;
+        try {
+            theFile = new File(pathName, classNameAsFile);
+            if (theFile.exists()) {
+                int length = (int) theFile.length();
+                theInput = new FileInputStream(theFile);
+                byte[] theBytes = new byte[length + 100];
+                int dataRead = 0;
+                while (dataRead < length) {
+                    int count = theInput.read(theBytes, dataRead,
+                            theBytes.length - dataRead);
+                    if (count == -1) {
+                        break;
+                    }
+                    dataRead += count;
+                }
+
+                if (dataRead > 0) {
+                    // Create the class from the bytes read in...
+                    theClass = this.defineClass(className, theBytes, 0, dataRead);
+                    ClassLoader testClassLoader = theClass.getClassLoader();
+                    if (testClassLoader != this) {
+                        System.out.println("findClass - wrong classloader!!");
+                    }
+                }
+            }
+        } catch (Exception e) {
+            System.out.println("findClass - exception reading class file.");
+            e.printStackTrace();
+        } finally {
+            try {
+                if (theInput != null) {
+                    theInput.close();
+                }
+            } catch (Exception e) {
+            }
+        }
+        return theClass;
+    }
+
+    /*
+     * Loads a named class from a specified JAR file
+     */
+    private Class<?> loadClassFromJar(String jarfileName, String className,
+            String classNameAsFile) {
+        Class<?> theClass = null;
+
+        // First, try to open the Jar file
+        JarFile theJar = null;
+        try {
+            theJar = new JarFile(jarfileName);
+            JarEntry theEntry = theJar.getJarEntry(classNameAsFile);
+
+            if (theEntry == null) {
+                // System.out.println("TestHelper_Classloader - did not find
+                // class file in Jar " + jarfileName );
+                return theClass;
+            } // end if
+
+            theEntry.getMethod();
+            InputStream theStream = theJar.getInputStream(theEntry);
+
+            long size = theEntry.getSize();
+            if (size < 0) {
+                size = 100000;
+            }
+            byte[] theBytes = new byte[(int) size + 100];
+
+            int dataRead = 0;
+            while (dataRead < size) {
+                int count = theStream.read(theBytes, dataRead, theBytes.length
+                        - dataRead);
+                if (count == -1) {
+                    break;
+                }
+                dataRead += count;
+            } // end while
+
+            // System.out.println("loadClassFromJar: read " + dataRead + " bytes
+            // from class file");
+            if (dataRead > 0) {
+                // Create the class from the bytes read in...
+                theClass = this.defineClass(className, theBytes, 0, dataRead);
+                /* System.out.println("findClass: created Class object."); */
+                ClassLoader testClassLoader = theClass.getClassLoader();
+                if (testClassLoader != this) {
+                    System.out.println("findClass - wrong classloader!!");
+                } else {
+                    System.out
+                            .println("Testclassloader loaded class from jar: "
+                                    + className);
+                } // end if
+            } // end if
+        } catch (IOException ie) {
+            System.out
+                    .println("TestHelper_ClassLoader: IOException opening Jar "
+                            + jarfileName);
+        } catch (Exception e) {
+            System.out
+                    .println("TestHelper_ClassLoader: Exception loading class from Jar ");
+        } catch (ClassFormatError ce) {
+            System.out
+                    .println("TestHelper_ClassLoader: ClassFormatException loading class from Jar ");
+        } finally {
+            try {
+                if (theJar != null) {
+                    theJar.close();
+                }
+            } catch (Exception e) {
+            } // end try
+        } // end try
+
+        return theClass;
+    } // end method loadClassFromJar(
+
+} // end class TestHelper_ClassLoader
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Connection1.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Connection1.java
new file mode 100644
index 0000000..8b1fd60
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Connection1.java
@@ -0,0 +1,176 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Savepoint;
+import java.sql.Statement;
+import java.util.Map;
+
+/**
+ * Helper class for the java.sql tests - a skeleton class which implements the
+ * java.sql.Connection interface
+ * 
+ */
+public class TestHelper_Connection1 implements Connection {
+    public void clearWarnings() throws SQLException {
+    }
+
+    public void close() throws SQLException {
+    }
+
+    public void commit() throws SQLException {
+    }
+
+    public Statement createStatement() throws SQLException {
+        return null;
+    }
+
+    public Statement createStatement(int resultSetType, int resultSetConcurrency,
+            int resultSetHoldability) throws SQLException {
+        return null;
+    }
+
+    public Statement createStatement(int resultSetType, int resultSetConcurrency)
+            throws SQLException {
+        return null;
+    }
+
+    public boolean getAutoCommit() throws SQLException {
+        return false;
+    }
+
+    public String getCatalog() throws SQLException {
+        return null;
+    }
+
+    public int getHoldability() throws SQLException {
+        return 0;
+    }
+
+    public DatabaseMetaData getMetaData() throws SQLException {
+        return null;
+    }
+
+    public int getTransactionIsolation() throws SQLException {
+        return 0;
+    }
+
+    public Map<String, Class<?>> getTypeMap() throws SQLException {
+        return null;
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return null;
+    }
+
+    public boolean isClosed() throws SQLException {
+        return false;
+    }
+
+    public boolean isReadOnly() throws SQLException {
+        return false;
+    }
+
+    public String nativeSQL(String sql) throws SQLException {
+        return null;
+    }
+
+    public CallableStatement prepareCall(String sql, int resultSetType,
+            int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+        return null;
+    }
+
+    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency)
+            throws SQLException {
+        return null;
+    }
+
+    public CallableStatement prepareCall(String sql) throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int resultSetType,
+            int resultSetConcurrency, int resultSetHoldability) throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int resultSetType,
+            int resultSetConcurrency) throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys)
+            throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql, int[] columnIndexes)
+            throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql, String[] columnNames)
+            throws SQLException {
+        return null;
+    }
+
+    public PreparedStatement prepareStatement(String sql) throws SQLException {
+        return null;
+    }
+
+    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
+    }
+
+    public void rollback() throws SQLException {
+    }
+
+    public void rollback(Savepoint savepoint) throws SQLException {
+    }
+
+    public void setAutoCommit(boolean autoCommit) throws SQLException {
+    }
+
+    public void setCatalog(String catalog) throws SQLException {
+    }
+
+    public void setHoldability(int holdability) throws SQLException {
+    }
+
+    public void setReadOnly(boolean readOnly) throws SQLException {
+    }
+
+    public Savepoint setSavepoint() throws SQLException {
+        return null;
+    }
+
+    public Savepoint setSavepoint(String name) throws SQLException {
+        return null;
+    }
+
+    public void setTransactionIsolation(int level) throws SQLException {
+    }
+
+    public void setTypeMap(Map<String, Class<?>> map) throws SQLException {
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver1.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver1.java
new file mode 100644
index 0000000..ae09f94
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver1.java
@@ -0,0 +1,116 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.SQLException;
+import java.util.Properties;
+
+/**
+ * A simple implementation of a class implementing a JDBC Driver, for use in the
+ * testing of the java.sql.DriverManager class
+ * 
+ */
+public class TestHelper_Driver1 implements Driver {
+    int majorVersion = 1;
+
+    int minorVersion = 0;
+
+    String baseURL = "jdbc:mikes1";
+
+    String[] dataSources = { "data1", "data2", "data3" };
+
+    static Driver theDriver;
+    static {
+        theDriver = new TestHelper_Driver1();
+        try {
+            DriverManager.registerDriver(theDriver);
+        } catch (SQLException e) {
+            System.out.println("Failed to register driver!");
+        }
+    } // end static block initializer
+
+    protected TestHelper_Driver1() {
+        super();
+    } // end constructor TestHelper_Driver1()
+
+    public boolean acceptsURL(String url) throws SQLException {
+        // Check on the supplied String...
+        if (url == null) {
+            return false;
+        }
+        // Everything's fine if the quoted url starts with the base url for this
+        // driver
+        if (url.startsWith(baseURL)) {
+            return true;
+        }
+        return false;
+    } // end method acceptsURL
+
+    static String validuser = "theuser";
+
+    static String validpassword = "thepassword";
+
+    static String userProperty = "user";
+
+    static String passwordProperty = "password";
+
+    public Connection connect(String url, Properties info) throws SQLException {
+        // Does the URL have the right form?
+        if (this.acceptsURL(url)) {
+            // The datasource name is the remainder of the url after the ":"
+            String datasource = url.substring(baseURL.length() + 1);
+            for (String element : dataSources) {
+                if (datasource.equals(element)) {
+                    /*
+                     * Check for user and password, except for datasource =
+                     * data1 which is set up not to require a user/password
+                     * combination
+                     */
+                    // It all checks out - so return a connection
+                    Connection connection = new TestHelper_Connection1();
+                    return connection;
+                } // end if
+            } // end for
+        } // end if
+        return null;
+    } // end method connect(String, Properties)
+
+    public int getMajorVersion() {
+        return majorVersion;
+    } // end method getMajorVersion()
+
+    public int getMinorVersion() {
+        return minorVersion;
+    } // end method getMinorVersion()
+
+    public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
+            throws SQLException {
+        DriverPropertyInfo[] theInfos = { new DriverPropertyInfo(userProperty, "*"),
+                new DriverPropertyInfo(passwordProperty, "*"), };
+        return theInfos;
+    }
+
+    public boolean jdbcCompliant() {
+        // Basic version here returns false
+        return false;
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver2.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver2.java
new file mode 100644
index 0000000..6d495d6
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver2.java
@@ -0,0 +1,50 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+/**
+ * Basic JDBC driver implementation to help with tests
+ * 
+ */
+public class TestHelper_Driver2 extends TestHelper_Driver1 {
+
+    static {
+        Driver theDriver = new TestHelper_Driver2();
+        /*
+         * System.out.println("Driver2 classloader: " +
+         * theDriver.getClass().getClassLoader() ); System.out.println("Driver2
+         * object is: " + theDriver );
+         */
+        try {
+            DriverManager.registerDriver(theDriver);
+        } catch (SQLException e) {
+            System.out.println("Failed to register driver!");
+        }
+    } // end static block initializer
+
+    protected TestHelper_Driver2() {
+        super();
+        baseURL = "jdbc:mikes2";
+    } // end constructor TestHelper_Driver1()
+
+} // end class TestHelper_Driver2
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver3.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver3.java
new file mode 100644
index 0000000..f02bdc3
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver3.java
@@ -0,0 +1,36 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+
+/**
+ * TODO Type description
+ * 
+ */
+public class TestHelper_Driver3 extends TestHelper_Driver1 {
+
+    /*
+     * This driver does NOT automatically register itself...
+     */
+
+    public TestHelper_Driver3() {
+        super();
+        baseURL = "jdbc:mikes3";
+    } // end constructor TestHelper_Driver1()
+
+} // end class TestHelper_Driver3
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver4.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver4.java
new file mode 100644
index 0000000..655436d
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver4.java
@@ -0,0 +1,129 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.SQLException;
+import java.util.Properties;
+
+/**
+ * Basic JDBC driver implementation to help with tests
+ * 
+ */
+public class TestHelper_Driver4 implements Driver {
+    int majorVersion = 1;
+
+    int minorVersion = 0;
+
+    String baseURL;
+
+    String[] dataSources = { "data1", "data2", "data3" };
+    static {
+        Driver theDriver = new TestHelper_Driver4();
+        try {
+            DriverManager.registerDriver(theDriver);
+        } catch (SQLException e) {
+            System.out.println("Failed to register driver!");
+        }
+    } // end static block initializer
+
+    protected TestHelper_Driver4() {
+        super();
+        baseURL = "jdbc:mikes4";
+    } // end constructor TestHelper_Driver4()
+
+    public boolean acceptsURL(String url) throws SQLException {
+        // Check on the supplied String...
+        if (url == null) {
+            return false;
+        }
+        // Everything's fine if the quoted url starts with the base url for this
+        // driver
+        if (url.startsWith(baseURL)) {
+            return true;
+        }
+        return false;
+    } // end method acceptsURL
+
+    static String validuser = "theuser";
+
+    static String validpassword = "thepassword";
+
+    static String userProperty = "user";
+
+    static String passwordProperty = "password";
+
+    public Connection connect(String url, Properties info) throws SQLException {
+        // Does the URL have the right form?
+        if (this.acceptsURL(url)) {
+            // The datasource name is the remainder of the url after the ":"
+            String datasource = url.substring(baseURL.length() + 1);
+            for (String element : dataSources) {
+                if (datasource.equals(element)) {
+                    /*
+                     * Check for user and password, except for datasource =
+                     * data1 which is set up not to require a user/password
+                     * combination
+                     */
+                    if (datasource.equals("data1")) {
+                        // do nothing...
+                    } else {
+                        if (info == null) {
+                            throw new SQLException("Properties bundle is null");
+                        }
+                        String user = (String) info.get(userProperty);
+                        String password = (String) info.get(passwordProperty);
+                        if (user == null || password == null) {
+                            throw new SQLException("Userid and/or password not supplied");
+                        }
+                        if (!user.equals(validuser) || !password.equals(validpassword)) {
+                            throw new SQLException("Userid and/or password not valid");
+                        } // end if
+                    } // end if
+                    // It all checks out - so return a connection
+                    Connection connection = new TestHelper_Connection1();
+                    return connection;
+                } // end if
+            } // end for
+        } // end if
+        return null;
+    } // end method connect(String, Properties)
+
+    public int getMajorVersion() {
+        return majorVersion;
+    } // end method getMajorVersion()
+
+    public int getMinorVersion() {
+        return minorVersion;
+    } // end method getMinorVersion()
+
+    public DriverPropertyInfo[] getPropertyInfo(String url, Properties info)
+            throws SQLException {
+        DriverPropertyInfo[] theInfos = { new DriverPropertyInfo(userProperty, "*"),
+                new DriverPropertyInfo(passwordProperty, "*"), };
+        return theInfos;
+    }
+
+    public boolean jdbcCompliant() {
+        // Basic version here returns false
+        return false;
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver5.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver5.java
new file mode 100644
index 0000000..b228466
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_Driver5.java
@@ -0,0 +1,44 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+
+/**
+ * Basic JDBC driver implementation to help with tests
+ * 
+ */
+public class TestHelper_Driver5 extends TestHelper_Driver4 {
+
+    static {
+        Driver theDriver = new TestHelper_Driver5();
+        try {
+            DriverManager.registerDriver(theDriver);
+        } catch (SQLException e) {
+            System.out.println("Failed to register driver!");
+        }
+    } // end static block initializer
+
+    protected TestHelper_Driver5() {
+        super();
+        baseURL = "jdbc:mikes5";
+    } // end constructor TestHelper_Driver5()
+
+} // end class TestHelper_Driver5
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_DriverManager.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_DriverManager.java
new file mode 100644
index 0000000..773684e
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TestHelper_DriverManager.java
@@ -0,0 +1,112 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(DriverManager.class)
+/**
+ * Helper class for the Driver manager tes - it allows the test code to be
+ * loaded under a different classloader, necessary for testing the
+ * DeregisterDriver function of DriverManager
+ * 
+ */
+public class TestHelper_DriverManager extends TestCase {
+
+    static Driver testDriver = null;
+
+    static TestHelper_DriverManager theHelper;
+
+    static {
+        theHelper = new TestHelper_DriverManager();
+        // theHelper.testDeregister();
+    } // end static
+
+    public TestHelper_DriverManager() {
+        super();
+    } // end constructor TestHelper_DriverManager()
+
+    public static void setDriver(Driver theDriver) {
+        testDriver = theDriver;
+      //  Logger.global.info("TestHelper_DriverManager: Test Driver set!");
+
+        theHelper.checkDeregister();
+    } // end method setDriver( Driver )
+
+    public void checkDeregister() {
+
+        String baseURL = "jdbc:mikes1";
+
+      //  Logger.global.info("Calling checkDeregister in TestHelper_DriverManager....");
+
+        Driver aDriver;
+
+       // Logger.global.info("checkDeregister classloader: this.getClass().getClassLoader()");
+
+        // Try to get a driver from the general pool... this should fail
+        try {
+            aDriver = DriverManager.getDriver(baseURL);
+            fail("testDeregisterDriver: Didn't get exception when getting valid driver from other classloader.");
+        } catch (SQLException e) {
+            // e.printStackTrace();
+            assertTrue(
+                    "testDeregisterDriver: Got exception when getting valid driver from other classloader.",
+                    true);
+            // return;
+        } // end try
+
+        // OK, now THIS driver was loaded by someone else....
+        aDriver = testDriver;
+
+        // printClassLoader( aDriver );
+
+        // Deregister this driver
+        try {
+            DriverManager.deregisterDriver(aDriver);
+            // We shouldn't get here - but if we do, we need to re-register the
+            // driver to
+            // prevent subsequent tests from failing due to inability to get to
+            // this driver...
+            DriverManager.registerDriver(aDriver);
+            fail("checkDeregisterDriver: Didn't get Security Exception deregistering invalid driver.");
+        } catch (SecurityException s) {
+            // This is the exception we should get...
+            // System.out.println("checkDeregisterDriver: got expected Security
+            // Exception");
+        } catch (Exception e) {
+            fail("checkDeregisterDriver: Got wrong exception type when deregistering invalid driver.");
+        } // end try
+
+    } // end method testDeRegister
+
+    static void printClassLoader(Object theObject) {
+        Class<? extends Object> theClass = theObject.getClass();
+        ClassLoader theClassLoader = theClass.getClassLoader();
+        System.out.println("ClassLoader is: " + theClassLoader.toString()
+                + " for object: " + theObject.toString());
+    } // end method printClassLoader( Object )
+
+} // end class TestHelper_DriverManager
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimeTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimeTest.java
new file mode 100644
index 0000000..d8451de
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimeTest.java
@@ -0,0 +1,389 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Time;
+import java.util.TimeZone;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(Time.class)
+/**
+ * JUnit Testcase for the java.sql.Time class
+ * 
+ */
+public class TimeTest extends TestCase {
+
+    static long TIME_TEST1 = 38720000; // 10:45:20 GMT
+
+    static long TIME_TEST2 = 80279000; // 22:17:59 GMT
+
+    static long TIME_TEST3 = -38720000; // 13:14:40 GMT
+
+    static String STRING_TEST1 = "10:45:20";
+
+    static String STRING_TEST2 = "22:17:59";
+
+    static String STRING_TEST3 = "13:14:40";
+
+    static String STRING_INVALID1 = "ABCDEFGHI";
+
+    static String STRING_INVALID2 = "233104";
+
+    static String STRING_INVALID3 = "21-43-48";
+
+    static String STRING_OUTRANGE = "35:99:66";
+
+    static long[] TIME_ARRAY = { TIME_TEST1, TIME_TEST2, TIME_TEST3 };
+
+    static String[] STRING_GMT_ARRAY = { STRING_TEST1, STRING_TEST2,
+            STRING_TEST3 };
+
+    static String[] STRING_LA_ARRAY = { "02:45:20", "14:17:59", "05:14:40" };
+
+    static String[] STRING_JP_ARRAY = { "19:45:20", "07:17:59", "22:14:40" };
+
+    static String[] INVALID_STRINGS = { STRING_INVALID1, STRING_INVALID2,
+            STRING_INVALID3 };
+
+    // Timezones
+    static String TZ_LONDON = "GMT"; // GMT (!) PS London != GMT (?!?)
+
+    static String TZ_PACIFIC = "America/Los_Angeles"; // GMT - 8
+
+    static String TZ_JAPAN = "Asia/Tokyo"; // GMT + 9
+
+    static String[] TIMEZONES = { TZ_LONDON, TZ_PACIFIC, TZ_JAPAN };
+
+    static String[][] STRING_ARRAYS = { STRING_GMT_ARRAY, STRING_LA_ARRAY,
+            STRING_JP_ARRAY };
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecated method",
+        method = "Time",
+        args = {int.class, int.class, int.class}
+    )
+    public void testTimeintintint() {
+        Time theTime = new Time(10, 45, 20);
+
+        // The date should have been created
+        assertNotNull(theTime);
+    } // end method testTimeintintint()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Incorrect parameter checking missed",
+        method = "Time",
+        args = {long.class}
+    )
+    public void testTime() {
+        Time theTime = new Time(TIME_TEST1);
+
+        // The date should have been created
+        assertNotNull(theTime);
+        assertTrue(theTime.toString().contains("10:45:20"));
+    } // end method testTime()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
+    public void testToString() {
+        // Loop through the timezones testing the String conversion for each
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            testToString(TIMEZONES[i], TIME_ARRAY, STRING_ARRAYS[i]);
+        } // end for
+
+    } // end method test
+
+    private void testToString(String timeZone, long[] theTimes,
+            String[] theTimeStrings) {
+        // Set the timezone
+        TimeZone.setDefault(TimeZone.getTimeZone(timeZone));
+
+        for (int i = 0; i < theTimes.length; i++) {
+            // Create the Time object
+            Time theTime = new Time(theTimes[i]);
+            // Convert to a time string ... and compare
+            String JDBCString = theTime.toString();
+            assertEquals(theTimeStrings[i], JDBCString);
+        } // end for
+
+    } // end testToString( String, long[], String[] )
+
+    /*
+     * Method test for valueOf
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+    public void testValueOfString() {
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        
+        Time[] theReturns = { new Time(38720000), new Time(80279000),
+                new Time(47680000)};
+        String[] validTime = { "10:45:20", "22:17:59", "13:14:40", };
+        String[] invalidTime = { null, "ABCDEFGHI", "233104", "21-43-48" };
+        
+        for (int i = 0; i < validTime.length; i++) {
+            Time theReturn = Time.valueOf(validTime[i]);
+                assertEquals(theReturns[i], theReturn);
+        } // end for
+        
+        for (String element : invalidTime) {
+            try {
+                Time.valueOf(element);
+                fail("Should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+        }
+
+    } // end method testValueOfString
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTime",
+        args = {long.class}
+    )
+    public void testSetTime() {
+        // Ensure that the timezone is set to GMT
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        Time theTime = new Time(TIME_TEST1);
+        assertEquals(STRING_TEST1, theTime.toString());
+
+        theTime.setTime(TIME_TEST2);
+        assertEquals(STRING_TEST2, theTime.toString());
+    } // end method testSetTime()
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setDate",
+        args = {int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testSetDate() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.setDate(10);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method testSetDate()
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setMonth",
+        args = {int.class}
+    )
+    public void testSetMonth() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.setMonth(2);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method testSetMonth()
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setYear",
+        args = {int.class}
+    )
+    public void testSetYear() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.setYear(99);
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method testSetYear()
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDate",
+        args = {}
+    )
+    public void testGetDate() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.getDate();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method test
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDay",
+        args = {}
+    )
+    public void testGetDay() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.getDay();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method test
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMonth",
+        args = {}
+    )
+    public void testGetMonth() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.getMonth();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method test
+
+    @SuppressWarnings("deprecation")
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getYear",
+        args = {}
+    )
+    public void testGetYear() {
+        Time theTime = new Time(TIME_TEST1);
+
+        try {
+            theTime.getYear();
+            fail("Should throw IllegalArgumentException.");
+        } catch (IllegalArgumentException e) {
+            //expected
+        } // end try
+    } // end method test
+    
+    /**
+     * @tests java.sql.Time#valueOf(String )
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+     public void test_valueOf_IllegalArgumentException() {
+            try{
+                Time.valueOf("15:43:12:34");
+                fail("should throw NumberFormatException");
+            } catch (NumberFormatException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf(":10:07:01");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf("::01");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf("11::");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf(":01:");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf(":10:w2:01");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+        
+            try{
+                Time.valueOf("07:w2:");
+                fail("should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf("17:w2:w2");
+                fail("should throw NumberFormatException");
+            } catch (NumberFormatException e) {
+                //expected
+            }
+            
+            try{
+                Time.valueOf("16::01");
+                fail("should throw NumberFormatException");
+            } catch (NumberFormatException e) {
+                //expected
+            }
+        }
+} // end class TimeTest
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimestampTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimestampTest.java
new file mode 100644
index 0000000..cdbc63c
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TimestampTest.java
@@ -0,0 +1,774 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Timestamp;
+import java.util.Date;
+import java.util.TimeZone;
+
+import org.apache.harmony.testframework.serialization.SerializationTest;
+import junit.framework.TestCase;
+
+@TestTargetClass(Timestamp.class)
+/**
+ * JUnit Testcase for the java.sql.Timestamp class
+ * 
+ */
+
+public class TimestampTest extends TestCase {
+
+    static long TIME_TEST1 = 38720231; // 10:45:20.231 GMT
+
+    static long TIME_TEST2 = 80279000; // 22:17:59.000 GMT
+
+    static long TIME_TEST3 = -38720691; // 13:14:39.309 GMT
+
+    static long TIME_COMPARE = 123498845;
+
+    static long TIME_EARLY = -2347889122L;// A time well before the Epoch
+
+    static long TIME_LATE = 2347889122L; // A time well after the Epoch
+
+    static String STRING_TEST1 = "1970-01-01 10:45:20.231"; // "1970-01-01
+                                                            // 10:45:20.231000000";
+
+    static String STRING_TEST2 = "1970-01-01 22:17:59.0"; // "1970-01-01
+                                                            // 22:17:59.000000000";
+
+    static String STRING_TEST3 = "1969-12-31 13:14:39.309"; // "1969-12-31
+                                                            // 13:14:39.309000000";
+
+    static String STRING_INVALID1 = "ABCDEFGHI";
+
+    static String STRING_INVALID2 = "233104";
+
+    static String STRING_INVALID3 = "21-43-48";
+
+    // A timepoint in the correct format but with numeric values out of range
+    // ...this is accepted despite being a crazy date specification
+    // ...it is treated as the correct format date 3000-06-08 12:40:06.875 !!
+    static String STRING_OUTRANGE = "2999-15-99 35:99:66.875";
+
+    static long[] TIME_ARRAY = { TIME_TEST1, TIME_TEST2, TIME_TEST3 };
+
+    static int[] YEAR_ARRAY = { 70, 70, 69 };
+
+    static int[] MONTH_ARRAY = { 0, 0, 11 };
+
+    static int[] DATE_ARRAY = { 1, 1, 31 };
+
+    static int[] HOURS_ARRAY = { 10, 22, 13 };
+
+    static int[] MINUTES_ARRAY = { 45, 17, 14 };
+
+    static int[] SECONDS_ARRAY = { 20, 59, 39 };
+
+    static int[] NANOS_ARRAY = { 231000000, 000000000, 309000000 };
+
+    static int[] NANOS_ARRAY2 = { 137891990, 635665198, 109985421 };
+
+    static String[] STRING_NANOS_ARRAY = { "1970-01-01 10:45:20.13789199",
+            "1970-01-01 22:17:59.635665198", "1969-12-31 13:14:39.109985421" };
+
+    static String[] STRING_GMT_ARRAY = { STRING_TEST1, STRING_TEST2,
+            STRING_TEST3 };
+
+    static String[] STRING_LA_ARRAY = { "02:45:20", "14:17:59", "05:14:40" };
+
+    static String[] STRING_JP_ARRAY = { "19:45:20", "07:17:59", "22:14:40" };
+
+    static String[] INVALID_STRINGS = { STRING_INVALID1, STRING_INVALID2,
+            STRING_INVALID3 };
+
+    // Timezones
+    static String TZ_LONDON = "GMT"; // GMT (!) PS London != GMT (?!?)
+
+    static String TZ_PACIFIC = "America/Los_Angeles"; // GMT - 8
+
+    static String TZ_JAPAN = "Asia/Tokyo"; // GMT + 9
+
+    static String[] TIMEZONES = { TZ_LONDON, TZ_PACIFIC, TZ_JAPAN };
+
+    static String[][] STRING_ARRAYS = { STRING_GMT_ARRAY, STRING_LA_ARRAY,
+            STRING_JP_ARRAY };
+
+    /*
+     * Constructor test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Incorrect parameter checking missed",
+        method = "Timestamp",
+        args = {long.class}
+    )
+    public void testTimestamplong() {
+        Timestamp theTimestamp = new Timestamp(TIME_TEST1);
+
+        // The Timestamp should have been created
+        assertNotNull(theTimestamp);
+    } // end method testTimestamplong
+
+    /*
+     * Constructor test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "Timestamp",
+        args = {int.class, int.class, int.class, int.class, int.class, int.class, int.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testTimestampintintintintintintint() {
+        int[][] valid = { { 99, 2, 14, 17, 52, 3, 213577212 }, // 0 valid
+                { 0, 0, 1, 0, 0, 0, 0 }, // 1 valid
+                { 106, 11, 31, 23, 59, 59, 999999999 }, // 2 valid
+                { 106, 11, 31, 23, 59, 61, 999999999 }, // 5 Seconds out of
+                                                        // range
+                { 106, 11, 31, 23, 59, -1, 999999999 }, // 6 Seconds out of
+                                                        // range
+                { 106, 11, 31, 23, 61, 59, 999999999 }, // 7 Minutes out of
+                                                        // range
+                { 106, 11, 31, 23, -1, 59, 999999999 }, // 8 Minutes out of
+                                                        // range
+                { 106, 11, 31, 25, 59, 59, 999999999 }, // 9 Hours out of range
+                { 106, 11, 31, -1, 59, 59, 999999999 }, // 10 Hours out of range
+                { 106, 11, 35, 23, 59, 59, 999999999 }, // 11 Days out of range
+                { 106, 11, -1, 23, 59, 59, 999999999 }, // 12 Days out of range
+                { 106, 15, 31, 23, 59, 59, 999999999 }, // 13 Months out of
+                                                        // range
+                { 106, -1, 31, 23, 59, 59, 999999999 }, // 14 Months out of
+                                                        // range
+                { -10, 11, 31, 23, 59, 59, 999999999 }, // 15 valid - Years
+                                                        // negative
+        };
+
+        for (int[] element : valid) {
+            Timestamp theTimestamp = new Timestamp(element[0],
+                    element[1], element[2], element[3],
+                    element[4], element[5], element[6]);
+            assertNotNull("Timestamp not generated: ", theTimestamp);
+        } // end for
+        
+        int[][] invalid = {
+                { 106, 11, 31, 23, 59, 59, 1999999999 }, 
+                { 106, 11, 31, 23, 59, 59, -999999999 },
+        };
+        for (int[] element : invalid) {
+            try {
+                new Timestamp(element[0],
+                        element[1], element[2], element[3],
+                        element[4], element[5], element[6]);
+                fail("Should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                // expected
+            }
+        }
+
+    } // end method testTimestampintintintintintintint
+
+    /*
+     * Method test for setTime
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTime",
+        args = {long.class}
+    )
+    public void testSetTimelong() {
+        // First set the timezone to GMT
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        Timestamp theTimestamp = new Timestamp(TIME_TEST1);
+
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            theTimestamp.setTime(TIME_ARRAY[i]);
+
+            assertEquals(TIME_ARRAY[i], theTimestamp.getTime());
+            assertEquals(NANOS_ARRAY[i], theTimestamp.getNanos());
+        } // end for
+
+    } // end method testsetTimelong
+
+    /*
+     * Method test for getTime
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTime",
+        args = {}
+    )
+    public void testGetTime() {
+        // First set the timezone to GMT
+        TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+            assertEquals(element, theTimestamp.getTime());
+        } // end for
+
+    } // end method testgetTime
+
+    /*
+     * Method test for getYear
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getYear",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetYear() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(YEAR_ARRAY[i], theTimestamp.getYear());
+        } // end for
+
+    } // end method testgetYear
+
+    /*
+     * Method test for getMonth
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getMonth",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetMonth() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(MONTH_ARRAY[i], theTimestamp.getMonth());
+        } // end for
+
+    } // end method testgetMonth
+
+    /*
+     * Method test for getDate
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getDate",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetDate() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(DATE_ARRAY[i], theTimestamp.getDate());
+        } // end for
+
+    } // end method testgetDate
+
+    /*
+     * Method test for getHours
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getHours",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetHours() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(HOURS_ARRAY[i], theTimestamp.getHours());
+        } // end for
+
+    } // end method testgetHours
+
+    /*
+     * Method test for getMinutes
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getMinutes",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetMinutes() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(MINUTES_ARRAY[i], theTimestamp.getMinutes());
+        } // end for
+
+    } // end method testgetMinutes
+
+    /*
+     * Method test for getSeconds
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Deprecation",
+        method = "getSeconds",
+        args = {}
+    )
+    @SuppressWarnings("deprecation")
+    public void testGetSeconds() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(SECONDS_ARRAY[i], theTimestamp.getSeconds());
+        } // end for
+
+    } // end method testgetSeconds
+
+    /*
+     * Method test for valueOf
+     */
+    static String theExceptionMessage = "Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+    public void testValueOfString() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            Timestamp theTimestamp2 = Timestamp.valueOf(STRING_GMT_ARRAY[i]);
+            assertEquals(theTimestamp, theTimestamp2);
+        } // end for
+
+        // Test for a string in correct format but with number values out of
+        // range
+        Timestamp theTimestamp = Timestamp.valueOf(STRING_OUTRANGE);
+        assertNotNull(theTimestamp);
+        /*
+         * System.out.println("testValueOfString: outrange timestamp: " +
+         * theTimestamp.toString() );
+         */
+
+        for (String element : INVALID_STRINGS) {
+            try {
+                Timestamp.valueOf(element);
+                fail("Should throw IllegalArgumentException.");
+            } catch (IllegalArgumentException e) {
+                //expected
+            } // end try
+
+        } // end for
+
+    } // end method testvalueOfString
+
+    /*
+     * Method test for valueOf
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "valueOf",
+        args = {java.lang.String.class}
+    )
+    public void testValueOfString1() {
+
+        Timestamp theReturn;
+        long[] theReturnTime = { 38720231, 38720231, 80279000, -38720691,
+                38720000};
+        int[] theReturnNanos = { 231000000, 231987654, 0, 309000000, 0,};
+        
+        String[] valid = { 
+                "1970-01-01 10:45:20.231",
+                "1970-01-01 10:45:20.231987654", 
+                "1970-01-01 22:17:59.0",
+                "1969-12-31 13:14:39.309", 
+                "1970-01-01 10:45:20",  
+        };
+        String[] invalid = {
+                null,
+                "ABCDEFGHI", 
+                "233104", "1970-01-01 22:17:59.",
+                "1970-01-01 10:45:20.231987654690645322",
+                "1970-01-01 10:45:20&231987654",
+                "1970-01-01 10:45:20.-31987654",
+                "1970-01-01 10:45:20.ABCD87654", 
+                "21-43-48",
+        };
+        
+        for (int i = 0; i < valid.length; i++) {
+                theReturn = Timestamp.valueOf(valid[i]);
+                assertEquals(theReturnTime[i], theReturn.getTime());
+                assertEquals(theReturnNanos[i], theReturn.getNanos());
+        } // end for
+
+        for (String element : invalid) {
+            try {
+                theReturn = Timestamp.valueOf(element);
+                fail("Should throw IllegalArgumentException.");
+            } catch (IllegalArgumentException e) {
+                //expected
+            }
+        }
+
+    } // end method testValueOfString
+
+    /*
+     * Method test for toString
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
+    public void testToString() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(STRING_GMT_ARRAY[i], theTimestamp.toString());
+        } // end for
+
+    } // end method testtoString
+
+    /*
+     * Method test for getNanos
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getNanos",
+        args = {}
+    )
+    public void testGetNanos() {
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            assertEquals(NANOS_ARRAY[i], theTimestamp.getNanos());
+        } // end for
+
+    } // end method testgetNanos
+
+    /*
+     * Method test for setNanos
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setNanos",
+        args = {int.class}
+    )
+    public void testSetNanosint() {
+        int[] NANOS_INVALID = { -137891990, 1635665198, -1 };
+        for (int i = 0; i < TIME_ARRAY.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+
+            theTimestamp.setNanos(NANOS_ARRAY2[i]);
+
+            assertEquals(NANOS_ARRAY2[i], theTimestamp.getNanos());
+            // Also check that these Timestamps with detailed nanos values
+            // convert to
+            // strings correctly
+            assertEquals(STRING_NANOS_ARRAY[i], theTimestamp.toString());
+        } // end for
+
+        for (int i = 0; i < NANOS_INVALID.length; i++) {
+            Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
+            int originalNanos = theTimestamp.getNanos();
+            try {
+                theTimestamp.setNanos(NANOS_INVALID[i]);
+                fail("Should throw IllegalArgumentException");
+            } catch (IllegalArgumentException e) {
+                //expected
+            } // end try
+
+            assertEquals(originalNanos, theTimestamp.getNanos());
+        } // end for
+
+    } // end method testsetNanosint
+
+    /*
+     * Method test for equals
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.sql.Timestamp.class}
+    )
+    public void testEqualsTimestamp() {
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+            Timestamp theTimestamp2 = new Timestamp(element);
+
+            assertTrue(theTimestamp.equals(theTimestamp2));
+        } // end for
+
+        Timestamp theTest = new Timestamp(TIME_COMPARE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+            assertFalse(theTimestamp.equals(theTest));
+        } // end for
+        
+        // Regression for HARMONY-526
+        assertFalse(new Timestamp(0).equals((Timestamp) null));
+    } // end method testequalsTimestamp
+
+    /*
+     * Method test for equals
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
+    public void testEqualsObject() {
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            Object theTimestamp2 = new Timestamp(element);
+
+            assertTrue(theTimestamp.equals(theTimestamp2));
+        } // end for
+
+        Object theTest = new Timestamp(TIME_COMPARE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertFalse(theTimestamp.equals(theTest));
+        } // end for
+
+        Object nastyTest = new String("Test ");
+        Timestamp theTimestamp = new Timestamp(TIME_ARRAY[1]);
+        assertFalse(theTimestamp.equals(nastyTest));
+
+        // Regression for HARMONY-526
+        assertFalse(new Timestamp(0).equals((Object) null));
+    } // end method testequalsObject
+
+    /*
+     * Method test for before
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "before",
+        args = {java.sql.Timestamp.class}
+    )
+    public void testBeforeTimestamp() {
+        Timestamp theTest = new Timestamp(TIME_LATE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertTrue(theTimestamp.before(theTest));
+        } // end for
+
+        theTest = new Timestamp(TIME_EARLY);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertFalse(theTimestamp.before(theTest));
+        } // end for
+
+        for (long element : TIME_ARRAY) {
+            theTest = new Timestamp(element);
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertFalse(theTimestamp.before(theTest));
+            theTest.setNanos(theTest.getNanos() + 1);
+            assertTrue(theTimestamp.before(theTest));
+        } // end for
+
+    } // end method testbeforeTimestamp
+
+    /*
+     * Method test for after
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "after",
+        args = {java.sql.Timestamp.class}
+    )
+    public void testAfterTimestamp() {
+        Timestamp theTest = new Timestamp(TIME_LATE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertFalse(theTimestamp.after(theTest));
+        } // end for
+
+        theTest = new Timestamp(TIME_EARLY);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertTrue(theTimestamp.after(theTest));
+        } // end for
+
+        for (long element : TIME_ARRAY) {
+            theTest = new Timestamp(element);
+            Timestamp theTimestamp = new Timestamp(element);
+
+            assertFalse(theTimestamp.after(theTest));
+            theTimestamp.setNanos(theTimestamp.getNanos() + 1);
+            assertTrue(theTimestamp.after(theTest));
+        } // end for
+
+    } // end method testafterTimestamp
+
+    /*
+     * Method test for compareTo
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.sql.Timestamp.class}
+    )
+    @SuppressWarnings("deprecation")
+    public void testCompareToTimestamp() {
+        Timestamp theTest = new Timestamp(TIME_EARLY);
+        Timestamp theTest2 = new Timestamp(TIME_LATE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+            Timestamp theTimestamp2 = new Timestamp(element);
+
+            assertTrue(theTimestamp.compareTo(theTest) > 0);
+            assertTrue(theTimestamp.compareTo(theTest2) < 0);
+            assertEquals(0, theTimestamp.compareTo(theTimestamp2));
+        } // end for
+        
+        Timestamp t1 = new Timestamp(-1L);
+        Timestamp t2 = new Timestamp(-1L);
+        
+        t1.setTime(Long.MIN_VALUE);
+        t2.setDate(Integer.MIN_VALUE);
+        assertEquals(1, t1.compareTo(t2));
+        assertEquals(-1, t2.compareTo(t1));
+
+        t1.setTime(Long.MAX_VALUE);
+        t2.setTime(Long.MAX_VALUE - 1);
+        assertEquals(1, t1.compareTo(t2));
+        assertEquals(-1, t2.compareTo(t1));
+
+        t1.setTime(Integer.MAX_VALUE);
+        t2.setTime(Integer.MAX_VALUE);
+        assertEquals(0, t1.compareTo(t2));
+        assertEquals(0, t2.compareTo(t1));
+
+    } // end method testcompareToTimestamp
+
+    /**
+     * @tests java.sql.Timestamp#compareTo(java.util.Date)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.util.Date.class}
+    )
+    public void testCompareToDate() {
+        Date theTest = new Timestamp(TIME_EARLY);
+        Date theTest2 = new Timestamp(TIME_LATE);
+
+        for (long element : TIME_ARRAY) {
+            Timestamp theTimestamp = new Timestamp(element);
+            Date theTimestamp2 = new Timestamp(element);
+
+            assertTrue(theTimestamp.compareTo(theTest) > 0);
+            assertTrue(theTimestamp.compareTo(theTest2) < 0);
+            assertEquals(0, theTimestamp.compareTo(theTimestamp2));
+        } // end for
+
+        Date nastyTest = new Date();
+        Timestamp theTimestamp = new Timestamp(TIME_ARRAY[1]);
+        try {
+            theTimestamp.compareTo(nastyTest);
+            // It throws ClassCastException in JDK 1.5.0_06 but in 1.5.0_07 it
+            // does not throw the expected exception.
+            fail("testCompareToObject: Did not get expected ClassCastException");
+        } catch (ClassCastException e) {
+            // Should get here
+            /*
+             * System.out.println("testCompareToObject: ClassCastException as
+             * expected"); System.out.println("Exception message: " +
+             * e.getMessage());
+             */
+        } // end try
+
+    } // end method testcompareToObject
+    
+    /**
+     * @tests serialization/deserialization compatibility.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Serialization test",
+        method = "!SerializationSelf",
+        args = {}
+    )
+    public void testSerializationSelf() throws Exception {
+        Timestamp object = new Timestamp(100L);
+        SerializationTest.verifySelf(object);
+    }
+
+    /**
+     * @tests serialization/deserialization compatibility with RI.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Serialization test",
+        method = "!SerializationGolden",
+        args = {}
+    )
+    public void testSerializationCompatibility() throws Exception {
+        Timestamp object = new Timestamp(100L);
+        SerializationTest.verifyGolden(this, object);
+    }
+    
+    /**
+     * @tests java.sql.Timestamp#toString()
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
+    public void test_toString() {
+
+        Timestamp t1 = new Timestamp(Long.MIN_VALUE);
+        assertEquals("292278994-08-17 07:12:55.192", t1.toString()); //$NON-NLS-1$
+
+        Timestamp t2 = new Timestamp(Long.MIN_VALUE + 1);
+        assertEquals("292278994-08-17 07:12:55.193", t2.toString()); //$NON-NLS-1$
+
+        Timestamp t3 = new Timestamp(Long.MIN_VALUE + 807);
+        assertEquals("292278994-08-17 07:12:55.999", t3.toString()); //$NON-NLS-1$
+
+        Timestamp t4 = new Timestamp(Long.MIN_VALUE + 808);
+        assertEquals("292269055-12-02 16:47:05.0", t4.toString()); //$NON-NLS-1$
+    }
+ 
+} // end class TimestampTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TypesTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TypesTest.java
new file mode 100644
index 0000000..948d95f
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/java/sql/TypesTest.java
@@ -0,0 +1,113 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(java.sql.Types.class)
+public class TypesTest extends TestCase {
+
+    /*
+     * Public statics test
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Field testing",
+        method = "!Constants",
+        args = {}
+    )
+    public void testPublicStatics() {
+
+        HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
+        thePublicStatics.put("BOOLEAN", new Integer(16));
+        thePublicStatics.put("DATALINK", new Integer(70));
+        thePublicStatics.put("REF", new Integer(2006));
+        thePublicStatics.put("CLOB", new Integer(2005));
+        thePublicStatics.put("BLOB", new Integer(2004));
+        thePublicStatics.put("ARRAY", new Integer(2003));
+        thePublicStatics.put("STRUCT", new Integer(2002));
+        thePublicStatics.put("DISTINCT", new Integer(2001));
+        thePublicStatics.put("JAVA_OBJECT", new Integer(2000));
+        thePublicStatics.put("OTHER", new Integer(1111));
+        thePublicStatics.put("NULL", new Integer(0));
+        thePublicStatics.put("LONGVARBINARY", new Integer(-4));
+        thePublicStatics.put("VARBINARY", new Integer(-3));
+        thePublicStatics.put("BINARY", new Integer(-2));
+        thePublicStatics.put("TIMESTAMP", new Integer(93));
+        thePublicStatics.put("TIME", new Integer(92));
+        thePublicStatics.put("DATE", new Integer(91));
+        thePublicStatics.put("LONGVARCHAR", new Integer(-1));
+        thePublicStatics.put("VARCHAR", new Integer(12));
+        thePublicStatics.put("CHAR", new Integer(1));
+        thePublicStatics.put("DECIMAL", new Integer(3));
+        thePublicStatics.put("NUMERIC", new Integer(2));
+        thePublicStatics.put("DOUBLE", new Integer(8));
+        thePublicStatics.put("REAL", new Integer(7));
+        thePublicStatics.put("FLOAT", new Integer(6));
+        thePublicStatics.put("BIGINT", new Integer(-5));
+        thePublicStatics.put("INTEGER", new Integer(4));
+        thePublicStatics.put("SMALLINT", new Integer(5));
+        thePublicStatics.put("TINYINT", new Integer(-6));
+        thePublicStatics.put("BIT", new Integer(-7));
+
+        Class<?> typesClass;
+        try {
+            typesClass = Class.forName("java.sql.Types");
+        } catch (ClassNotFoundException e) {
+            fail("java.sql.Types class not found!");
+            return;
+        } // end try
+
+        Field[] theFields = typesClass.getDeclaredFields();
+        int requiredModifier = Modifier.PUBLIC + Modifier.STATIC
+                + Modifier.FINAL;
+
+        int countPublicStatics = 0;
+        for (Field element : theFields) {
+            String fieldName = element.getName();
+            int theMods = element.getModifiers();
+            if (Modifier.isPublic(theMods) && Modifier.isStatic(theMods)) {
+                try {
+                    Object fieldValue = element.get(null);
+                    Object expectedValue = thePublicStatics.get(fieldName);
+                    if (expectedValue == null) {
+                        fail("Field " + fieldName + " missing!");
+                    } // end
+                    assertEquals("Field " + fieldName + " value mismatch: ",
+                            expectedValue, fieldValue);
+                    assertEquals("Field " + fieldName + " modifier mismatch: ",
+                            requiredModifier, theMods);
+                    countPublicStatics++;
+                } catch (IllegalAccessException e) {
+                    fail("Illegal access to Field " + fieldName);
+                } // end try
+            } // end if
+        } // end for
+
+    } // end method testPublicStatics
+
+} // end class TypesTest
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/AllTests.java b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/AllTests.java
new file mode 100644
index 0000000..abbb8b0
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/AllTests.java
@@ -0,0 +1,42 @@
+/*
+ * 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 org.apache.harmony.sql.tests.javax.sql;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * This is autogenerated source file. Includes tests for package org.apache.harmony.sql.tests.javax.sql;
+ */
+
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(AllTests.suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("All tests for package org.apache.harmony.sql.tests.javax.sql;");
+        // $JUnit-BEGIN$
+
+        suite.addTestSuite(ConnectionEventTest.class);
+        suite.addTestSuite(RowSetEventTest.class);
+
+        // $JUnit-END$
+        return suite;
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/ConnectionEventTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/ConnectionEventTest.java
new file mode 100644
index 0000000..376b173
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/ConnectionEventTest.java
@@ -0,0 +1,116 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.sql.SQLException;
+
+import javax.sql.ConnectionEvent;
+import javax.sql.PooledConnection;
+
+@TestTargetClass(ConnectionEvent.class)
+public class ConnectionEventTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#ConnectionEvent(PooledConnection)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "functional test missing but not feasible: no implementation available.",
+        method = "ConnectionEvent",
+        args = {javax.sql.PooledConnection.class}
+    )  
+    public void testConstructorConnection() {
+        try {
+            new ConnectionEvent(null);
+            fail("illegal argument exception expected");
+        } catch (IllegalArgumentException e) {
+        }
+        
+        Impl_PooledConnection ipc = new Impl_PooledConnection();
+        ConnectionEvent ce = new ConnectionEvent(ipc);
+        assertSame(ipc, ce.getSource());
+        assertNull(ce.getSQLException());
+        
+        //cross test
+        ConnectionEvent ce2 = new ConnectionEvent(ipc,null);
+        assertSame(ce2.getSource(),ce.getSource());
+    }
+    
+    
+    
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#ConnectionEvent(PooledConnection, SQLException)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "functional test missing but not feasible: no implementation available.",
+        method = "ConnectionEvent",
+        args = {javax.sql.PooledConnection.class, java.sql.SQLException.class}
+    )  
+    public void testConstructorConnectionSQLException() {
+        try {
+            new ConnectionEvent(null, null);
+            fail("illegal argument exception expected");
+        } catch (IllegalArgumentException e) {
+        }
+        
+        Impl_PooledConnection ipc = new Impl_PooledConnection();
+        ConnectionEvent ce = new ConnectionEvent(ipc, null);
+        assertSame(ipc, ce.getSource());
+        assertNull(ce.getSQLException());
+        
+        SQLException e = new SQLException();
+        ce = new ConnectionEvent(ipc, e);
+        assertSame(ipc, ce.getSource());
+        assertSame(e, ce.getSQLException());
+    }
+    
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#getSQLException()}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "functional test missing but not feasible: no implementation available.",
+        method = "getSQLException",
+        args = {}
+    )    
+    public void testGetSQLException() {
+
+        Impl_PooledConnection ipc = new Impl_PooledConnection();
+        ConnectionEvent ce = new ConnectionEvent(ipc);
+        
+        ConnectionEvent ce2 = new ConnectionEvent(ipc, null);
+        assertNull(ce.getSQLException());
+        assertEquals(ce2.getSQLException(), ce.getSQLException());
+        
+        SQLException e = new SQLException();
+        ConnectionEvent ce3 = new ConnectionEvent(ipc, e);
+        assertNotNull(ce3.getSQLException());
+        assertNotSame(ce3.getSQLException(), ce2.getSQLException());
+
+    }
+}   
+
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_PooledConnection.java b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_PooledConnection.java
new file mode 100644
index 0000000..d135ced
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_PooledConnection.java
@@ -0,0 +1,38 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.javax.sql;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+import javax.sql.ConnectionEventListener;
+import javax.sql.PooledConnection;
+
+class Impl_PooledConnection implements PooledConnection {
+    public void addConnectionEventListener(ConnectionEventListener theListener) {
+    }
+
+    public void close() throws SQLException {
+    }
+
+    public Connection getConnection() throws SQLException {
+        return null;
+    }
+
+    public void removeConnectionEventListener(ConnectionEventListener theListener) {
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_RowSet.java b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_RowSet.java
new file mode 100644
index 0000000..ace6b9a
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/Impl_RowSet.java
@@ -0,0 +1,738 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.javax.sql;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Map;
+import javax.sql.RowSet;
+import javax.sql.RowSetListener;
+
+@SuppressWarnings("deprecation")
+class Impl_RowSet implements RowSet {
+    public void addRowSetListener(RowSetListener theListener) {
+    }
+
+    public void clearParameters() throws SQLException {
+    }
+
+    public void execute() throws SQLException {
+    }
+
+    public String getCommand() {
+        return null;
+    }
+
+    public String getDataSourceName() {
+        return null;
+    }
+
+    public boolean getEscapeProcessing() throws SQLException {
+        return false;
+    }
+
+    public int getMaxFieldSize() throws SQLException {
+        return 0;
+    }
+
+    public int getMaxRows() throws SQLException {
+        return 0;
+    }
+
+    public String getPassword() {
+        return null;
+    }
+
+    public int getQueryTimeout() throws SQLException {
+        return 0;
+    }
+
+    public int getTransactionIsolation() {
+        return 0;
+    }
+
+    public Map<String, Class<?>> getTypeMap() throws SQLException {
+        return null;
+    }
+
+    public String getUrl() throws SQLException {
+        return null;
+    }
+
+    public String getUsername() {
+        return null;
+    }
+
+    public boolean isReadOnly() {
+        return false;
+    }
+
+    public void removeRowSetListener(RowSetListener theListener) {
+    }
+
+    public void setArray(int parameterIndex, Array theArray) throws SQLException {
+    }
+
+    public void setAsciiStream(int parameterIndex, InputStream theInputStream, int length)
+            throws SQLException {
+    }
+
+    public void setBigDecimal(int parameterIndex, BigDecimal theBigDecimal) throws SQLException {
+    }
+
+    public void setBinaryStream(int parameterIndex, InputStream theInputStream, int length)
+            throws SQLException {
+    }
+
+    public void setBlob(int parameterIndex, Blob theBlob) throws SQLException {
+    }
+
+    public void setBoolean(int parameterIndex, boolean theBoolean) throws SQLException {
+    }
+
+    public void setByte(int parameterIndex, byte theByte) throws SQLException {
+    }
+
+    public void setBytes(int parameterIndex, byte[] theByteArray) throws SQLException {
+    }
+
+    public void setCharacterStream(int parameterIndex, Reader theReader, int length)
+            throws SQLException {
+    }
+
+    public void setClob(int parameterIndex, Clob theClob) throws SQLException {
+    }
+
+    public void setCommand(String cmd) throws SQLException {
+    }
+
+    public void setConcurrency(int concurrency) throws SQLException {
+    }
+
+    public void setDataSourceName(String name) throws SQLException {
+    }
+
+    public void setDate(int parameterIndex, Date theDate, Calendar theCalendar)
+            throws SQLException {
+    }
+
+    public void setDate(int parameterIndex, Date theDate) throws SQLException {
+    }
+
+    public void setDouble(int parameterIndex, double theDouble) throws SQLException {
+    }
+
+    public void setEscapeProcessing(boolean enable) throws SQLException {
+    }
+
+    public void setFloat(int parameterIndex, float theFloat) throws SQLException {
+    }
+
+    public void setInt(int parameterIndex, int theInteger) throws SQLException {
+    }
+
+    public void setLong(int parameterIndex, long theLong) throws SQLException {
+    }
+
+    public void setMaxFieldSize(int max) throws SQLException {
+    }
+
+    public void setMaxRows(int max) throws SQLException {
+    }
+
+    public void setNull(int parameterIndex, int sqlType, String typeName) throws SQLException {
+    }
+
+    public void setNull(int parameterIndex, int sqlType) throws SQLException {
+    }
+
+    public void setObject(int parameterIndex, Object theObject, int targetSqlType, int scale)
+            throws SQLException {
+    }
+
+    public void setObject(int parameterIndex, Object theObject, int targetSqlType)
+            throws SQLException {
+    }
+
+    public void setObject(int parameterIndex, Object theObject) throws SQLException {
+    }
+
+    public void setPassword(String password) throws SQLException {
+    }
+
+    public void setQueryTimeout(int seconds) throws SQLException {
+    }
+
+    public void setReadOnly(boolean readOnly) throws SQLException {
+    }
+
+    public void setRef(int parameterIndex, Ref theRef) throws SQLException {
+    }
+
+    public void setShort(int parameterIndex, short theShort) throws SQLException {
+    }
+
+    public void setString(int parameterIndex, String theString) throws SQLException {
+    }
+
+    public void setTime(int parameterIndex, Time theTime, Calendar theCalendar)
+            throws SQLException {
+    }
+
+    public void setTime(int parameterIndex, Time theTime) throws SQLException {
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp theTimestamp, Calendar theCalendar)
+            throws SQLException {
+    }
+
+    public void setTimestamp(int parameterIndex, Timestamp theTimestamp) throws SQLException {
+    }
+
+    public void setTransactionIsolation(int level) throws SQLException {
+    }
+
+    public void setType(int type) throws SQLException {
+    }
+
+    public void setTypeMap(Map<String, Class<?>> theTypeMap) throws SQLException {
+    }
+
+    public void setUrl(String theURL) throws SQLException {
+    }
+
+    public void setUsername(String theUsername) throws SQLException {
+    }
+
+    public boolean absolute(int row) throws SQLException {
+        return false;
+    }
+
+    public void afterLast() throws SQLException {
+    }
+
+    public void beforeFirst() throws SQLException {
+    }
+
+    public void cancelRowUpdates() throws SQLException {
+    }
+
+    public void clearWarnings() throws SQLException {
+    }
+
+    public void close() throws SQLException {
+    }
+
+    public void deleteRow() throws SQLException {
+    }
+
+    public int findColumn(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public boolean first() throws SQLException {
+        return false;
+    }
+
+    public Array getArray(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Array getArray(String colName) throws SQLException {
+        return null;
+    }
+
+    public InputStream getAsciiStream(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public InputStream getAsciiStream(String columnName) throws SQLException {
+        return null;
+    }
+
+    public BigDecimal getBigDecimal(int columnIndex, int scale) throws SQLException {
+        return null;
+    }
+
+    public BigDecimal getBigDecimal(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public BigDecimal getBigDecimal(String columnName, int scale) throws SQLException {
+        return null;
+    }
+
+    public BigDecimal getBigDecimal(String columnName) throws SQLException {
+        return null;
+    }
+
+    public InputStream getBinaryStream(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public InputStream getBinaryStream(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Blob getBlob(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Blob getBlob(String columnName) throws SQLException {
+        return null;
+    }
+
+    public boolean getBoolean(int columnIndex) throws SQLException {
+        return false;
+    }
+
+    public boolean getBoolean(String columnName) throws SQLException {
+        return false;
+    }
+
+    public byte getByte(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public byte getByte(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public byte[] getBytes(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public byte[] getBytes(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Reader getCharacterStream(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Reader getCharacterStream(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Clob getClob(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Clob getClob(String colName) throws SQLException {
+        return null;
+    }
+
+    public int getConcurrency() throws SQLException {
+        return 0;
+    }
+
+    public String getCursorName() throws SQLException {
+        return null;
+    }
+
+    public Date getDate(int columnIndex, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Date getDate(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Date getDate(String columnName, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Date getDate(String columnName) throws SQLException {
+        return null;
+    }
+
+    public double getDouble(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public double getDouble(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public int getFetchDirection() throws SQLException {
+        return 0;
+    }
+
+    public int getFetchSize() throws SQLException {
+        return 0;
+    }
+
+    public float getFloat(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public float getFloat(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public int getInt(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public int getInt(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public long getLong(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public long getLong(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public ResultSetMetaData getMetaData() throws SQLException {
+        return null;
+    }
+
+    public Object getObject(int columnIndex, Map<String, Class<?>> map) throws SQLException {
+        return null;
+    }
+
+    public Object getObject(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Object getObject(String columnName, Map<String, Class<?>> map) throws SQLException {
+        return null;
+    }
+
+    public Object getObject(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Ref getRef(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Ref getRef(String colName) throws SQLException {
+        return null;
+    }
+
+    public int getRow() throws SQLException {
+        return 0;
+    }
+
+    public short getShort(int columnIndex) throws SQLException {
+        return 0;
+    }
+
+    public short getShort(String columnName) throws SQLException {
+        return 0;
+    }
+
+    public Statement getStatement() throws SQLException {
+        return null;
+    }
+
+    public String getString(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public String getString(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Time getTime(int columnIndex, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Time getTime(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Time getTime(String columnName, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Time getTime(String columnName) throws SQLException {
+        return null;
+    }
+
+    public Timestamp getTimestamp(int columnIndex, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Timestamp getTimestamp(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public Timestamp getTimestamp(String columnName, Calendar cal) throws SQLException {
+        return null;
+    }
+
+    public Timestamp getTimestamp(String columnName) throws SQLException {
+        return null;
+    }
+
+    public int getType() throws SQLException {
+        return 0;
+    }
+
+    public InputStream getUnicodeStream(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public InputStream getUnicodeStream(String columnName) throws SQLException {
+        return null;
+    }
+
+    public URL getURL(int columnIndex) throws SQLException {
+        return null;
+    }
+
+    public URL getURL(String columnName) throws SQLException {
+        return null;
+    }
+
+    public SQLWarning getWarnings() throws SQLException {
+        return null;
+    }
+
+    public void insertRow() throws SQLException {
+    }
+
+    public boolean isAfterLast() throws SQLException {
+        return false;
+    }
+
+    public boolean isBeforeFirst() throws SQLException {
+        return false;
+    }
+
+    public boolean isFirst() throws SQLException {
+        return false;
+    }
+
+    public boolean isLast() throws SQLException {
+        return false;
+    }
+
+    public boolean last() throws SQLException {
+        return false;
+    }
+
+    public void moveToCurrentRow() throws SQLException {
+    }
+
+    public void moveToInsertRow() throws SQLException {
+    }
+
+    public boolean next() throws SQLException {
+        return false;
+    }
+
+    public boolean previous() throws SQLException {
+        return false;
+    }
+
+    public void refreshRow() throws SQLException {
+    }
+
+    public boolean relative(int rows) throws SQLException {
+        return false;
+    }
+
+    public boolean rowDeleted() throws SQLException {
+        return false;
+    }
+
+    public boolean rowInserted() throws SQLException {
+        return false;
+    }
+
+    public boolean rowUpdated() throws SQLException {
+        return false;
+    }
+
+    public void setFetchDirection(int direction) throws SQLException {
+    }
+
+    public void setFetchSize(int rows) throws SQLException {
+    }
+
+    public void updateArray(int columnIndex, Array x) throws SQLException {
+    }
+
+    public void updateArray(String columnName, Array x) throws SQLException {
+    }
+
+    public void updateAsciiStream(int columnIndex, InputStream x, int length)
+            throws SQLException {
+    }
+
+    public void updateAsciiStream(String columnName, InputStream x, int length)
+            throws SQLException {
+    }
+
+    public void updateBigDecimal(int columnIndex, BigDecimal x) throws SQLException {
+    }
+
+    public void updateBigDecimal(String columnName, BigDecimal x) throws SQLException {
+    }
+
+    public void updateBinaryStream(int columnIndex, InputStream x, int length)
+            throws SQLException {
+    }
+
+    public void updateBinaryStream(String columnName, InputStream x, int length)
+            throws SQLException {
+    }
+
+    public void updateBlob(int columnIndex, Blob x) throws SQLException {
+    }
+
+    public void updateBlob(String columnName, Blob x) throws SQLException {
+    }
+
+    public void updateBoolean(int columnIndex, boolean x) throws SQLException {
+    }
+
+    public void updateBoolean(String columnName, boolean x) throws SQLException {
+    }
+
+    public void updateByte(int columnIndex, byte x) throws SQLException {
+    }
+
+    public void updateByte(String columnName, byte x) throws SQLException {
+    }
+
+    public void updateBytes(int columnIndex, byte[] x) throws SQLException {
+    }
+
+    public void updateBytes(String columnName, byte[] x) throws SQLException {
+    }
+
+    public void updateCharacterStream(int columnIndex, Reader x, int length)
+            throws SQLException {
+    }
+
+    public void updateCharacterStream(String columnName, Reader reader, int length)
+            throws SQLException {
+    }
+
+    public void updateClob(int columnIndex, Clob x) throws SQLException {
+    }
+
+    public void updateClob(String columnName, Clob x) throws SQLException {
+    }
+
+    public void updateDate(int columnIndex, Date x) throws SQLException {
+    }
+
+    public void updateDate(String columnName, Date x) throws SQLException {
+    }
+
+    public void updateDouble(int columnIndex, double x) throws SQLException {
+    }
+
+    public void updateDouble(String columnName, double x) throws SQLException {
+    }
+
+    public void updateFloat(int columnIndex, float x) throws SQLException {
+    }
+
+    public void updateFloat(String columnName, float x) throws SQLException {
+    }
+
+    public void updateInt(int columnIndex, int x) throws SQLException {
+    }
+
+    public void updateInt(String columnName, int x) throws SQLException {
+    }
+
+    public void updateLong(int columnIndex, long x) throws SQLException {
+    }
+
+    public void updateLong(String columnName, long x) throws SQLException {
+    }
+
+    public void updateNull(int columnIndex) throws SQLException {
+    }
+
+    public void updateNull(String columnName) throws SQLException {
+    }
+
+    public void updateObject(int columnIndex, Object x, int scale) throws SQLException {
+    }
+
+    public void updateObject(int columnIndex, Object x) throws SQLException {
+    }
+
+    public void updateObject(String columnName, Object x, int scale) throws SQLException {
+    }
+
+    public void updateObject(String columnName, Object x) throws SQLException {
+    }
+
+    public void updateRef(int columnIndex, Ref x) throws SQLException {
+    }
+
+    public void updateRef(String columnName, Ref x) throws SQLException {
+    }
+
+    public void updateRow() throws SQLException {
+    }
+
+    public void updateShort(int columnIndex, short x) throws SQLException {
+    }
+
+    public void updateShort(String columnName, short x) throws SQLException {
+    }
+
+    public void updateString(int columnIndex, String x) throws SQLException {
+    }
+
+    public void updateString(String columnName, String x) throws SQLException {
+    }
+
+    public void updateTime(int columnIndex, Time x) throws SQLException {
+    }
+
+    public void updateTime(String columnName, Time x) throws SQLException {
+    }
+
+    public void updateTimestamp(int columnIndex, Timestamp x) throws SQLException {
+    }
+
+    public void updateTimestamp(String columnName, Timestamp x) throws SQLException {
+    }
+
+    public boolean wasNull() throws SQLException {
+        return false;
+    }
+}
diff --git a/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/RowSetEventTest.java b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/RowSetEventTest.java
new file mode 100644
index 0000000..bf30fbc
--- /dev/null
+++ b/sql/src/test/java/org/apache/harmony/sql/tests/javax/sql/RowSetEventTest.java
@@ -0,0 +1,55 @@
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 org.apache.harmony.sql.tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import javax.sql.ConnectionEvent;
+import javax.sql.RowSet;
+import javax.sql.RowSetEvent;
+import junit.framework.TestCase;
+
+@TestTargetClass(RowSetEvent.class)
+public class RowSetEventTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.RowSetEvent#RowSetEvent(javax.sql.RowSet)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "functional test missing but not feasible: no implementation available.",
+        method = "RowSetEvent",
+        args = {javax.sql.RowSet.class}
+    )    
+    public void testConstructor() {
+        try {
+            new RowSetEvent(null);
+            fail("illegal argument exception expected");
+        } catch (IllegalArgumentException e) {
+        }
+        
+        Impl_RowSet irs = new Impl_RowSet();
+        RowSetEvent rse = new RowSetEvent(irs);
+        assertSame(irs, rse.getSource());
+    }
+    
+    
+}
diff --git a/sql/src/test/java/tests/SQLite/AbstractSqlTest.java b/sql/src/test/java/tests/SQLite/AbstractSqlTest.java
new file mode 100644
index 0000000..0c7fa61
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/AbstractSqlTest.java
@@ -0,0 +1,244 @@
+/*
+ * 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.SQLite;
+
+import SQLite.Callback;
+import SQLite.Database;
+import SQLite.Exception;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+
+/**
+ * This class provides SQL unit test, which can be used by subclasses eg. to
+ * test JDBC drivers.
+ */
+@TestTargetClass(Database.class)
+abstract class AbstractSqlTest extends TestCase {
+
+    /**
+     * The first connection.
+     */
+    private Connection firstConnection;
+
+    /**
+     * The second connection.
+     */
+    private Connection secondConnection;
+    
+    /**
+     * The statement from the first connection.
+     */
+    private Statement firstStmt;
+
+    /**
+     * The statement from the second connection.
+     */
+    private Statement secondStmt;
+
+    /**
+     * The values of the first column "one".
+     */
+    private final String[] ones = {"hello!", "goodbye"};
+
+    /**
+     * The values of the second column "two".
+     */
+    private final short[] twos = {10, 20};
+
+    /**
+     * The updated values of the first column "one".
+     */
+    private final String[] ones_updated;
+
+    /** Creates a new instance of this class */
+    public AbstractSqlTest() {
+        super();
+        ones_updated = new String[ones.length];
+        for (int i = 0; i < ones.length; i++) {
+            ones_updated[i] = ones[i] + twos[i];
+        }
+    }
+
+    /**
+     * Sets up a unit test, by creating two statements from two connections and
+     * creating a test table.
+     * 
+     * @exception SQLException if there is a problem accessing the database
+     * @throws Exception 
+     * @exception Exception may be thrown by subclasses
+     */
+    @Override
+    protected void setUp() throws InstantiationException,
+            IllegalAccessException, ClassNotFoundException, SQLException, Exception {
+        Class.forName(getDriverClassName()).newInstance();
+        firstConnection = DriverManager.getConnection(getConnectionURL());
+        firstConnection.setTransactionIsolation(getTransactionIsolation());
+        secondConnection = DriverManager.getConnection(getConnectionURL());
+        secondConnection.setTransactionIsolation(getTransactionIsolation());
+        firstStmt = firstConnection.createStatement();
+        firstStmt.execute("create table tbl1(one varchar(10), two smallint)");
+        secondStmt = secondConnection.createStatement();
+    }
+
+    /**
+     * Tears down a unit test, by setting the auto commit property of the first
+     * connection back to true, dropping the test table and closing the two
+     * connections.
+     */
+    @Override
+    protected void tearDown() throws SQLException {
+        firstStmt.close();
+        secondStmt.close();
+        firstConnection.setAutoCommit(true);
+        firstStmt = firstConnection.createStatement();
+        firstStmt.execute("drop table tbl1");
+        firstStmt.close();
+        firstConnection.close();
+        secondConnection.close();
+    }
+
+    /**
+     * Adds some rows to the test table and asserts that the rows can be
+     * retrieved again.
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void autoCommitInsertSelect() throws SQLException {
+        firstStmt.getConnection().setAutoCommit(true);
+        for (int i = 0; i < ones.length; i++) {
+            firstStmt.execute("insert into tbl1 values('" + ones[i] + "',"
+                    + twos[i] + ")");
+        }
+        assertAllFromTbl1(firstStmt, ones, twos);
+    }
+
+    /**
+     * Asserts that the expected values can be selected from the test table.
+     * 
+     * @param stmt the statement to be used for the selection of the data
+     * @param ones the expected values of the column 'one'
+     * @param twos the expected values of the column 'two'
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void assertAllFromTbl1(Statement stmt, String[] ones, short[] twos)
+            throws SQLException {
+        ResultSet rs = stmt.executeQuery("select * from tbl1");
+        int i = 0;
+        for (; rs.next(); i++) {
+            assertTrue(i < ones.length);
+            assertEquals(ones[i], rs.getString("one"));
+            assertEquals(twos[i], rs.getShort("two"));
+        }
+        assertTrue(i == ones.length);
+    }
+    
+    @TestTargetNew(
+      level = TestLevel.PARTIAL_COMPLETE,
+      notes = "",
+      clazz = Database.class,
+      method = "exec",
+      args = {String.class, Callback.class}
+    )
+    public void testAutoCommitInsertSelect() throws SQLException{
+        autoCommitInsertSelect();
+    }
+    
+    /**
+     * Tests the following sequence after successful insertion of some test
+     * data: 
+     * - update data from connection one 
+     * - select data from connection two (-> should have the old values) 
+     * - commit data from connection one 
+     * - select data from connection two (-> should have the new values)
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    @TestTargetNew(
+      level = TestLevel.PARTIAL_COMPLETE,
+      notes = "",
+      clazz = Database.class,
+      method = "exec",
+      args = {String.class, Callback.class}
+      )
+    public void testUpdateSelectCommitSelect() throws SQLException {
+        autoCommitInsertSelect();
+        firstStmt.getConnection().setAutoCommit(false);
+        updateOnes(firstStmt, ones_updated, twos);
+        assertAllFromTbl1(secondStmt, ones, twos);
+        firstStmt.getConnection().commit();
+        assertAllFromTbl1(secondStmt, ones_updated, twos);
+    }
+
+    /**
+     * Tests the following sequence after successful insertion of some test
+     * data: 
+     * - update data from connection one 
+     * - select data from connection two (-> should have the old values) 
+     * - rollback data from connection one 
+     * - select data from connection two (-> should still have the old values)
+     * 
+     * @throws SQLException if there is a problem accessing the database
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            clazz = Database.class,
+            method = "exec",
+            args = {String.class, Callback.class}
+    )
+    public void testUpdateSelectRollbackSelect() throws SQLException {
+        autoCommitInsertSelect();
+        firstStmt.getConnection().setAutoCommit(false);
+        updateOnes(firstStmt, ones_updated, twos);
+        assertAllFromTbl1(secondStmt, ones, twos);
+        firstStmt.getConnection().rollback();
+        assertAllFromTbl1(secondStmt, ones, twos);
+    }
+
+    /**
+     * Updates the values in column 'one'
+     * @param stmt the statement to be used to update the data
+     * @param ones_updated the updated valus of column 'one'
+     * @param twos the reference values of column 'two'
+     * @throws SQLException if there is a problem accessing the database
+     */
+    private void updateOnes(Statement stmt, String[] ones_updated, short[] twos)
+            throws SQLException {
+        for (int i = 0; i < ones_updated.length; i++) {
+            stmt.execute("UPDATE tbl1 SET one = '" + ones_updated[i]
+                    + "' WHERE two = " + twos[i]);
+        }
+    }
+
+    protected abstract String getConnectionURL();
+    
+    protected abstract String getDriverClassName();
+    
+    protected abstract int getTransactionIsolation();
+
+}
diff --git a/sql/src/test/java/tests/SQLite/AllTests.java b/sql/src/test/java/tests/SQLite/AllTests.java
new file mode 100644
index 0000000..2cf0f61
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/AllTests.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+public class AllTests {
+
+    //All tests executed with sqlite3 only
+    public static Test suite() {
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("Tests for SQLite");
+        //$JUnit-BEGIN$
+        suite.addTestSuite(DatabaseTest.class);
+        suite.addTestSuite(JDBCDriverFunctionalTest.class);
+        suite.addTestSuite(JDBCDriverTest.class);
+        suite.addTestSuite(ConstantsTest.class);
+        suite.addTestSuite(BlobTest.class);
+        suite.addTestSuite(StmtTest.class);
+        suite.addTestSuite(ExceptionTest.class);
+        suite.addTestSuite(FunctionContextTest.class);
+        //$JUnit-END$
+        return suite;
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/BlobTest.java b/sql/src/test/java/tests/SQLite/BlobTest.java
new file mode 100644
index 0000000..71f2005
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/BlobTest.java
@@ -0,0 +1,235 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Blob;
+import SQLite.Database;
+import SQLite.Exception;
+import SQLite.Stmt;
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
+
+import junit.framework.TestCase;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+@TestTargetClass(Blob.class)
+public class BlobTest extends SQLiteTest {
+    
+    private static Blob testBlob = null;
+    
+    private byte[] blobInput= null;
+    
+    private static InputStream file = null;
+    
+    private static Database db = null;
+    
+    private static Stmt st = null;
+    
+    public class MockBlob extends Blob {
+        public void finalize() {
+            try {
+                super.finalize();
+            } catch (Throwable exception) {
+                fail("Test activity faild!");
+            }
+        }
+    }
+    
+    public void setUp() throws java.lang.Exception {
+        super.setUp();
+        testBlob = new Blob();
+        
+        super.setUp();
+        Support_SQL.loadDriver();
+        db = new Database();
+        db.open(dbFile.getPath(), 0);
+             
+        db.exec("create table B(id integer primary key, val blob)",null);
+        db.exec("insert into B values(1, zeroblob(128))", null);
+        db.exec("insert into B values(2, zeroblob(128))", null);
+        db.exec("insert into B values(3, zeroblob(128))", null);
+        
+        // can not fill Blob with data at this point...
+        /*
+        File resources = Support_Resources.createTempFolder();
+        BufferedReader r = null;
+        try {
+            Class c = Class.forName(this.getClass().getName());
+            assertNotNull(c);
+            file = Class.forName(this.getClass().getName())
+                    .getResourceAsStream("/blob.c");
+            r = new BufferedReader(new InputStreamReader(file));
+        } catch (NullPointerException e) {
+            fail("Should not throw NullPointerException reading file"
+                    + e.getMessage());
+        }
+        OutputStream out = testBlob.getOutputStream();
+        String s = null;
+        while ((s = r.readLine()) != null) {
+            out.write(r.readLine().getBytes());
+        }
+        out.flush();
+        out.close();
+        testBlob.close();
+        */
+    }
+
+    public void tearDown() {
+        
+        testBlob.close();
+        super.tearDown();
+    }
+    
+    /**
+     * @throws Exception 
+     * @throws IOException 
+     * @tests Blob#Blob()
+     */
+    @TestTargets ( {
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "db.open_blob is not supported also for Stmt, therefore cannot test Blobs",
+        method = "Blob",
+        args = {}
+    ),
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "functional test",
+        method = "getOutputStream",
+        args = {}    
+    ),
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "functional test",
+        method = "getInputStream",
+        args = {}
+    )
+    })
+    @KnownFailure("db.open_blob is not supported.")
+    public void testBlob() throws Exception, IOException {
+        byte[] b = new byte[4];
+        byte[] b128 = new byte[128];
+        for (int i = 0; i < b128.length; i++) {
+        b128[i] = (byte) i;
+        }
+        Blob blob = db.open_blob(dbFile.getPath(), "B", "val", 1, true);
+        try {
+            
+        OutputStream os = blob.getOutputStream();
+        os.write(b128);
+        os.close();
+        
+        InputStream is = blob.getInputStream();
+        is.skip(96);
+        assertEquals(4,is.read(b));
+        is.close();
+        } finally {
+        blob.close();
+        }
+    }
+
+    /**
+     * @tests Blob#finalize()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "Can not be checked. Should be tested in DX test package.",
+        method = "finalize",
+        args = {}
+    )
+    public void testFinalize() {
+        
+    }
+
+    /**
+     * @tests Blob.getInputStream()
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Exception test",
+        method = "getInputStream",
+        args = {}
+    )
+    public void testGetInputStream() {
+        InputStream in = testBlob.getInputStream();
+        
+        try {
+            in.read();
+            fail("Exception not thrown for invalid Blob.");
+        } catch (Throwable e) {
+            //ok
+        }   
+    }
+
+    /**
+     * @tests Blob#getOutputStream()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Exception test",
+        method = "getOutputStream",
+        args = {}
+    )
+    public void testGetOutputStream() {
+        OutputStream out = testBlob.getOutputStream();
+       
+        try {
+           out.write(null);
+           fail("Write operation unsupported");
+        } catch (Throwable e) {
+            assertEquals("Write operation unsupported", e.getMessage());
+        }
+    }
+
+    /**
+     * @tests Blob#close()
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not clear from spec what should happen when Blob is closed.",
+        method = "close",
+        args = {}
+    )
+    @KnownFailure("Blob does not clean up inputStream.")
+    public void testClose() {
+    assertNotNull(testBlob);
+       
+    testBlob.close();
+    // inputStream eithter null or some error occurs
+    try {
+        assertNull(testBlob.getInputStream());
+    } catch (Throwable e) {
+        //ok
+    }
+    
+    try {
+        assertNull(testBlob.getOutputStream());
+    } catch (Throwable e) {
+        //ok
+    }
+      
+    }
+}
diff --git a/sql/src/test/java/tests/SQLite/ConstantsTest.java b/sql/src/test/java/tests/SQLite/ConstantsTest.java
new file mode 100644
index 0000000..2a4961f
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/ConstantsTest.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Constants;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(Constants.class)
+public class ConstantsTest extends TestCase {
+
+    /**
+     * @tests Constants#Constants()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "constructor test",
+        method = "Constants",
+        args = {}
+    )
+    public void testConstants() {
+        Constants c = new Constants();
+            
+        assertNotNull(c);
+        assertEquals(c.SQLITE_OK, 0);
+        assertEquals(c.SQLITE_ERROR, 1);
+        assertEquals(c.SQLITE_INTERNAL, 2);
+        assertEquals(c.SQLITE_PERM, 3);
+        assertEquals(c.SQLITE_ABORT, 4);
+        assertEquals(c.SQLITE_BUSY, 5);
+        assertEquals(c.SQLITE_LOCKED, 6);
+        assertEquals(c.SQLITE_NOMEM, 7);
+        assertEquals(c.SQLITE_READONLY, 8);
+        assertEquals(c.SQLITE_INTERRUPT, 9);
+        assertEquals(c.SQLITE_IOERR, 10);
+        assertEquals(c.SQLITE_CORRUPT, 11);
+        assertEquals(c.SQLITE_NOTFOUND, 12);
+        assertEquals(c.SQLITE_FULL, 13);
+        assertEquals(c.SQLITE_CANTOPEN, 14);
+        assertEquals(c.SQLITE_PROTOCOL, 15);
+        assertEquals(c.SQLITE_EMPTY, 16);
+        assertEquals(c.SQLITE_SCHEMA, 17);
+        assertEquals(c.SQLITE_TOOBIG, 18);
+        assertEquals(c.SQLITE_CONSTRAINT, 19);
+        assertEquals(c.SQLITE_MISMATCH, 20);
+        assertEquals(c.SQLITE_MISUSE, 21);
+        assertEquals(c.SQLITE_NOLFS, 22);
+        assertEquals(c.SQLITE_AUTH, 23);
+        assertEquals(c.SQLITE_FORMAT, 24);
+        assertEquals(c.SQLITE_RANGE, 25);
+        assertEquals(c.SQLITE_NOTADB, 26);
+        assertEquals(c.SQLITE_ROW, 100);
+        assertEquals(c.SQLITE_DONE, 101);
+        assertEquals(c.SQLITE_INTEGER, 1);
+        assertEquals(c.SQLITE_FLOAT, 2);
+        assertEquals(c.SQLITE_BLOB, 4);
+        assertEquals(c.SQLITE_NULL, 5);
+        assertEquals(c.SQLITE3_TEXT, 3);
+        assertEquals(c.SQLITE_NUMERIC, -1);
+        assertEquals(c.SQLITE_TEXT, 3);
+        assertEquals(c.SQLITE2_TEXT, -2);
+        assertEquals(c.SQLITE_ARGS, -3);
+        assertEquals(c.SQLITE_COPY, 0);
+        assertEquals(c.SQLITE_CREATE_INDEX, 1);
+        assertEquals(c.SQLITE_CREATE_TABLE, 2);
+        assertEquals(c.SQLITE_CREATE_TEMP_INDEX, 3);
+        assertEquals(c.SQLITE_CREATE_TEMP_TABLE, 4);
+        assertEquals(c.SQLITE_CREATE_TEMP_TRIGGER, 5);
+        assertEquals(c.SQLITE_CREATE_TEMP_VIEW, 6);
+        assertEquals(c.SQLITE_CREATE_TRIGGER, 7);
+        assertEquals(c.SQLITE_CREATE_VIEW, 8);
+        assertEquals(c.SQLITE_DELETE, 9);
+        assertEquals(c.SQLITE_DROP_INDEX, 10);
+        assertEquals(c.SQLITE_DROP_TABLE, 11);
+        assertEquals(c.SQLITE_DROP_TEMP_INDEX, 12);
+        assertEquals(c.SQLITE_DROP_TEMP_TABLE, 13);
+        assertEquals(c.SQLITE_DROP_TEMP_TRIGGER, 14);
+        assertEquals(c.SQLITE_DROP_TEMP_VIEW, 15);
+        assertEquals(c.SQLITE_DROP_TRIGGER, 16);
+        assertEquals(c.SQLITE_DROP_VIEW, 17);
+        assertEquals(c.SQLITE_INSERT, 18);
+        assertEquals(c.SQLITE_PRAGMA, 19);
+        assertEquals(c.SQLITE_READ, 20);
+        assertEquals(c.SQLITE_SELECT, 21);
+        assertEquals(c.SQLITE_TRANSACTION, 22);
+        assertEquals(c.SQLITE_UPDATE, 23);
+        assertEquals(c.SQLITE_ATTACH, 24);
+        assertEquals(c.SQLITE_DETACH, 25);
+        assertEquals(c.SQLITE_DENY, 1);
+        assertEquals(c.SQLITE_IGNORE, 2);
+    }
+}
diff --git a/sql/src/test/java/tests/SQLite/DatabaseTest.java b/sql/src/test/java/tests/SQLite/DatabaseTest.java
new file mode 100644
index 0000000..50eb6cc
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/DatabaseTest.java
@@ -0,0 +1,2037 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
+import tests.support.DatabaseCreator;
+import tests.support.MockFunction;
+import tests.support.ThreadPool;
+import tests.support.resource.Support_Resources;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.UnsupportedEncodingException;
+import java.net.URL;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import SQLite.Authorizer;
+import SQLite.Blob;
+import SQLite.BusyHandler;
+import SQLite.Callback;
+import SQLite.Constants;
+import SQLite.Database;
+import SQLite.Exception;
+import SQLite.Function;
+import SQLite.FunctionContext;
+import SQLite.ProgressHandler;
+import SQLite.Stmt;
+import SQLite.TableResult;
+import SQLite.Trace;
+import SQLite.Vm;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.logging.Logger;
+
+@TestTargetClass(Database.class)
+public class DatabaseTest extends SQLiteTest {
+    
+    /**
+     * The SQLite db file.
+     */
+//    protected final File dbFile = new File("sqliteTest.db");
+//    
+//    private final String connectionURL = "jdbc:sqlite:/" + dbFile.getPath();
+//    
+//    private final String classname = "SQLite.JDBCDriver";
+//    
+//    private static Connection conn = null;
+    
+    private static ErrorTracker tracker = null;
+    
+    private Statement statement;
+    
+    private Database db = null;
+    
+    private static final int numThreads = 10;
+    
+    private static final int numOfRecords = 30;
+    
+    public void setUp() throws java.lang.Exception {
+        try {
+            super.setUp();
+            assertNotNull("Could not establish DB connection",conn);
+            tracker = new ErrorTracker();
+            
+            statement = conn.createStatement();
+            
+          //Cleanup tables if necessary
+            
+            DatabaseMetaData meta = conn.getMetaData();
+            assertNotNull(meta);
+            if (meta != null) {
+            ResultSet userTab = meta.getTables(null, null, null, null);
+            while (userTab.next()) {
+            String tableName = userTab.getString("TABLE_NAME");
+               this.statement.execute("drop table "+tableName);
+            }
+            }
+            
+            // Create default test table
+//            statement = conn.createStatement();
+            statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
+            statement.close();
+            
+            try {
+            db = new Database();
+            db.open(dbFile.getPath(), 0);
+            db.busy_handler(null);
+            } catch (Exception e) {
+                System.out.println("2: Error opening File: Dir "+dbFile.getPath()+" Name: "+dbFile.getPath());
+            } catch (java.lang.Exception e) {
+                System.err.println("Non SQLException "+e.getMessage());
+            }
+        } catch (Exception e) {
+            System.out.println("Database setup fails: "+e.getMessage());
+            e.printStackTrace();
+        }
+
+    }
+
+    public void tearDown() {
+       
+        try {
+            db.close();
+        }catch (Exception e) {
+            if (! (e.getMessage().equals("database already closed"))) {
+                System.err.println("Error closing DB "+dbFile.getPath());
+            }
+        }
+//        conn.close();
+//        dbFile.delete();
+        tracker.reset();
+        super.tearDown();
+    }
+    
+    /**
+     * @tests Database#Database()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "constructor test",
+        method = "Database",
+        args = {}
+    )
+    public void testDatabase() {
+        // db closed
+        Database db2 = new Database();
+        try {
+            db.close();
+            db2 = new Database();
+            db2.open(dbFile.getPath(), 0);
+            db2.close();
+            db.open(dbFile.getPath(), 0);
+        } catch (Exception e) {
+            fail("Database object could not be created "+e.getMessage());
+            e.printStackTrace();
+        }
+        //db is open
+        try {
+            db2.open(dbFile.getPath(), 0);
+            db2.close();          
+        } catch (Exception e) {
+            fail("Second Database object could not be created "+e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * @tests Database#finalize()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "method test",
+        method = "finalize",
+        args = {}
+    )
+    public void testFinalize() {
+    }
+
+    /**
+     * @tests {@link Database#open(String, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test. Test fails.",
+        method = "open",
+        args = {java.lang.String.class, int.class}
+    )
+    public void testOpen() {
+        try {
+            db.close();
+            db.open(dbFile.getPath(), 0);
+        } catch (Exception e) {
+            fail("Database object could not be opened: " + e.getMessage());
+            e.printStackTrace();
+        }
+        // open second db while db1 still open
+        Database db2 = new Database();
+        try {
+            db2.open(dbFile.getPath(), 0);
+            db2.open(dbFile.getPath(), 0);
+            db2.close();
+        } catch (Exception e) {
+            fail("Database object could not be opened: " + e.getMessage());
+            e.printStackTrace();
+        }
+        // open non db file
+        File tempDir = Support_Resources.createTempFolder();
+        final String resourceName = "blob.c";
+        try {
+            URL file = Class.forName(this.getClass().getName())
+            .getResource("/blob.c");
+            db2.open(file.getPath(), 0);
+           fail("Should not be able to open non db file");
+        } catch (Exception e) {
+            assertEquals("unknown error in open", e.getMessage());
+        } catch (java.lang.Exception e) {
+            fail("Error in setup " + e.getMessage());
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * @tests Database#open_aux_file(String)
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "open_aux_file",
+        args = {java.lang.String.class}
+    )
+    public void testOpen_aux_file() {
+        File temp = null;
+        try {
+            db.open_aux_file("");
+            fail("open should fail");
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+        
+     /*   
+        try {
+            temp = File.createTempFile("openAuxMethod", ".db");
+            db.open_aux_file("");
+            db.exec("create table AUX_TABLE", null);
+            db.close();
+        } catch (Exception e) {
+            temp.delete();
+            fail("Error handling temporary file "+e.getMessage());
+            e.printStackTrace();
+        } catch (IOException e) {
+            temp.delete();
+            fail("Could not create temporary File");
+            e.printStackTrace();
+        }
+        try {
+            db.open(dbFile.getPath(),0);
+            db.exec("select * from AUX_TABLE", null);
+            fail("Statement should fail");
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+       
+        temp.delete();
+        */
+    }
+
+    /**
+     * @tests Database#close()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "close",
+        args = {}
+    )
+    public void testClose() {
+        try {
+            db.close();
+            db.get_table("test");
+        } catch (Exception e) {
+            assertTrue(e.getMessage().equals("database already closed"));
+            try {
+                db.open(dbFile.getPath(), 0);
+            } catch (Exception e1) {
+                fail("Database object could not be reopened after 'close': "
+                        + e.getMessage());
+                e1.printStackTrace();
+            }
+        }
+        
+        try {
+            db.close();
+            db.close();
+        } catch (Exception e) {
+            assertTrue(e.getMessage().equals("database already closed"));
+            try {
+                db.open(dbFile.getPath(), 0);
+            } catch (Exception e1) {
+                fail("Database object could not be reopened after 'close': "
+                        + e.getMessage());
+                e1.printStackTrace();
+            }
+        }
+    }
+
+    /**
+     * @tests Database#exec(String, Callback)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "exec",
+        args = {java.lang.String.class, Callback.class}
+    )
+    public void testExecStringCallback() {
+        TableResult res = new TableResult();
+        try {
+            db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " VALUES(1, 10, 20)", null);
+            db.exec("select * from " + DatabaseCreator.SIMPLE_TABLE1, res);
+            db
+                    .exec("delete from " + DatabaseCreator.SIMPLE_TABLE1
+                            + " where 1", null);
+        } catch (Exception e) {
+            fail("Database error");
+            e.printStackTrace();
+        }
+        String row[] = (String[]) res.rows.elementAt(0);
+        assertEquals(Integer.parseInt(row[0]), 1);
+        assertEquals(Integer.parseInt(row[1]), 10);
+        assertEquals(Integer.parseInt(row[2]), 20);
+    }
+
+    /**
+     * @tests Database#exec(String, Callback, String[])
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "exec",
+        args = {java.lang.String.class, Callback.class, java.lang.String[].class}
+    )
+    public void testExecStringCallbackStringArray() {
+        TableResult res = new TableResult();
+        String args[] = new String[1];
+        args[0] = "table";
+        try {
+            db.exec("select name from sqlite_master where type = '%q';", res,
+                    args);
+            String[] s = (String[]) res.rows.elementAt(0);
+            assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1);
+        } catch (Exception e) {
+            fail("DB Error occurred");
+            e.printStackTrace();
+        }
+
+        try {
+            db.exec("select name from sqlite_master where type = ", res, args);
+            fail("Testmethod should fail");
+        } catch (Exception e) {
+            // Ok
+        }
+    }
+
+    /**
+     * @tests {@link Database#last_insert_rowid()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "last_insert_rowid",
+        args = {}
+    )
+    public void testLast_insert_rowid() {
+        assertEquals(0, db.last_insert_rowid());
+        try {
+            db
+                    .exec(
+                            "create table TEST5(id integer, firstname text, lastname text);",
+                            null);
+            db.exec("insert into TEST5 values (1,'James','Bond');", null);
+            db.exec("insert into TEST5 values (2,'Fiona','Apple');", null);
+        } catch (Exception e) {
+            fail("Error in test setup: " + e.getMessage());
+            e.printStackTrace();
+        }
+        assertEquals(2, db.last_insert_rowid());
+        assertEquals(db.last_insert_rowid(), db.last_insert_rowid());
+
+        try {
+            db.exec("drop table TEST5;", null);
+        } catch (Exception e) {
+            fail("Error in test setup: " + e.getMessage());
+            e.printStackTrace();
+        }
+        assertEquals(2, db.last_insert_rowid());
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Database#interrupt()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "interrupt",
+        args = {}
+    )
+    @KnownFailure("Reason for failure unknown: Database should be locked. " +
+                   "Specification of interrupt is scarce.")
+    public void testInterrupt() throws Exception {
+        ThreadPool threadPool = new ThreadPool(numThreads);
+
+        // initialization
+        ResultSet userTabs;
+        try {
+            userTabs = conn.getMetaData().getTables(null, null, null, null);
+            while (userTabs.next()) {
+                String tableName = userTabs.getString("TABLE_NAME");
+                if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                }
+            }
+            db.exec(DatabaseCreator.CREATE_TABLE3, null);
+            db.exec(DatabaseCreator.CREATE_TABLE1, null);
+        } catch (SQLException e1) {
+            fail("Error initializing test " + e1.toString());
+            e1.printStackTrace();
+        } catch (Exception e) {
+            fail("Error initializing test " + e.getMessage());
+            e.printStackTrace();
+        }
+
+        int id1 = numOfRecords - 3;
+        threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker));
+        // should not be able to do any other insertions since task 1 holds lock
+        int id2 = numOfRecords + 3;
+        threadPool
+                .runTask(createTask2Interrupt(id2, dbFile.getPath(), tracker));
+
+        threadPool.join();
+
+        List<String> errors = tracker.getErrors();
+        System.out.println("Last error: " + db.error_message());
+        if (errors.size() > 0) {
+            assertEquals(errors.get(0), db
+                    .error_string(Constants.SQLITE_LOCKED));
+            for (String s : errors) {
+                Logger.global.info("INTERRUPT Error: " + s);
+            }
+
+        } else {
+            fail("Should have one exception: database should be locked.");
+        }
+
+        // reset
+
+        db
+                .exec(
+                        "delete from " + DatabaseCreator.TEST_TABLE1
+                                + " where 1", null);
+        db
+                .exec(
+                        "delete from " + DatabaseCreator.TEST_TABLE3
+                                + " where 1", null);
+
+    }
+
+    /**
+     * @tests {@link Database#changes()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "test fails",
+        method = "changes",
+        args = {}
+    )
+    @KnownFailure("Returns wrong number for updates: returns value > 1 for select.")
+    public void testChanges() {
+        TableResult res = new TableResult();
+        try {
+            assertTrue(db.changes() == 0);
+            db.exec("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE1
+                    + " VALUES(2, 5, 7);", null);
+            int rows = (int) db.changes();
+            assertEquals(1,db.changes());
+            db.exec("update " + DatabaseCreator.SIMPLE_TABLE1
+                    + " set speed = 7, size= 5 where id = 2;", null);
+            assertEquals(1,db.changes());
+            db.exec("select * from " + DatabaseCreator.SIMPLE_TABLE1, res);
+            assertEquals(0,db.changes());
+            db.exec("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE1
+                    + " VALUES(8, 5, 7);", null);
+            db.exec("Update "+DatabaseCreator.SIMPLE_TABLE1+" set speed = 10;",null);
+           assertTrue(db.changes() > 2);
+        } catch (Exception e) {
+            fail("Could not get changes: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @throws SQLException 
+     * @throws Exception 
+     * @tests {@link Database#busy_handler(BusyHandler)}
+     */
+    @TestTargets({
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "method test fails once in a while. Cannot be sure that exception is thrown every time.",
+        method = "busy_handler",
+        args = {BusyHandler.class}
+    ),
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "method test fails once in a while. Cannot be sure that exception is thrown every time.",
+            method = "busy",
+            clazz = BusyHandler.class,
+            args = {java.lang.String.class, int.class}
+        )
+    })
+    @KnownFailure("method test fails once in a while. "+
+            "Cannot be sure that exception is thrown in every test execution.")
+    public void testBusy_handler() throws SQLException, Exception {
+        TestBusyHandler bh = new TestBusyHandler();
+        db.busy_handler(bh);
+        int counter = 0;
+        ThreadPool threadPool = new ThreadPool(numThreads);
+
+        // initialization
+        ResultSet userTabs;
+        try {
+            userTabs = conn.getMetaData().getTables(null, null, null, null);
+            while (userTabs.next()) {
+                String tableName = userTabs.getString("TABLE_NAME");
+                if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                }
+            }
+            db.exec(DatabaseCreator.CREATE_TABLE3, null);
+            db.exec(DatabaseCreator.CREATE_TABLE1, null);
+        } catch (SQLException e1) {
+            fail("Error initializing test " + e1.toString());
+            e1.printStackTrace();
+        } catch (Exception e) {
+            fail("Error initializing test " + e.getMessage());
+            e.printStackTrace();
+        }
+
+        
+//        try {
+//            DatabaseCreator.fillTestTable1(conn, numOfRecords);
+            // set to fail immediately if table is locked.
+//            db.busy_handler(bh);
+//            db.busy_timeout(0);
+        try {
+            conn.setAutoCommit(false);
+            int id1 = numOfRecords - 3;
+            threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker));
+            int id2 = numOfRecords + 3;
+            threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker));
+            int oldID = 5;
+            int newID = 100;
+            threadPool.runTask(createTask3(oldID, dbFile.getPath(), newID,
+                    tracker));
+
+            threadPool.join();
+
+            List<String> errors = tracker.getErrors();
+            if (errors.size() > 0) {
+//                 assertEquals(errors.get(0),
+//                 db.error_string(Constants.SQLITE_LOCKED));
+                for (String s: errors) {
+                  System.out.println("Round 2 Error: "+s);
+              }
+            } else {
+                fail("No error happened");
+            }
+            
+            // reset
+            
+
+            db.exec("delete from " + DatabaseCreator.TEST_TABLE1 + " where 1",
+                    null);
+            db.exec("delete from " + DatabaseCreator.TEST_TABLE3 + " where 1",
+                            null);
+//            
+//            // increase timeout for retry
+//            db.busy_timeout(1000);
+//            db.busy_handler(bh);
+//            tracker.reset();
+           
+//            threadPool = new ThreadPool(numThreads);
+//            
+//            threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker));
+//            threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker));
+//            
+//            threadPool.join();
+//            
+//            errors = tracker.getErrors();
+//            if (errors.size() > 0) {
+//                // assertEquals(errors.get(0),
+//                // db.error_string(Constants.SQLITE_LOCKED));
+//                for (String s: errors) {
+//                    System.out.println("Round 2 Error"+s);
+//                }
+//            } else {
+//                // ok
+//                System.out.println("BUSY: No Error!");
+//            }
+//            
+//
+        } catch (Exception e) {
+            fail("Error in test setup " + e.getMessage());
+            try {
+                db.get_table("select * from " + DatabaseCreator.TEST_TABLE1,
+                        null).toString();
+            } catch (Exception e1) {
+
+                e1.printStackTrace();
+            }
+            e.printStackTrace();
+//             } catch (SQLException e2) {
+//             System.out.println("Error in test setup "+e2.toString());
+//             try {
+//             db.get_table("select * from "+DatabaseCreator.TEST_TABLE1,null).
+//             toString();
+//             } catch (Exception e1) {
+//             e2.printStackTrace();
+//             }
+        } finally {
+            conn.setAutoCommit(true);
+            db.exec(DatabaseCreator.DROP_TABLE1, null);
+            db.exec(DatabaseCreator.DROP_TABLE3, null);
+        }
+    }
+    
+    /**
+     * @throws Exception 
+     * @throws SQLException 
+     * @tests {@link Database#busy_timeout(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "test fails. Cannot be sure that exception is thrown every time.",
+        method = "busy_timeout",
+        args = {int.class}
+    )
+    @KnownFailure("Database does not lock values")
+    public void testBusy_timeout() throws Exception, SQLException {
+        int counter = 0;
+        ThreadPool threadPool = new ThreadPool(numThreads);
+        
+        // initialization
+        ResultSet userTabs;
+        try {
+            userTabs = conn.getMetaData().getTables(null, null, null, null);
+            while (userTabs.next()) {
+                String tableName = userTabs.getString("TABLE_NAME");
+                if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                }
+            }
+            db.exec(DatabaseCreator.CREATE_TABLE3, null);
+            db.exec(DatabaseCreator.CREATE_TABLE1, null);
+        } catch (SQLException e1) {
+            fail("Error initializing test " + e1.toString());
+            e1.printStackTrace();
+        } catch (Exception e) {
+            fail("Error initializing test " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        
+        // test run
+        try {
+            conn.setAutoCommit(false);
+        
+//            DatabaseCreator.fillTestTable1(conn, numOfRecords);
+            // set to fail immediately if table is locked.
+            db.busy_handler(null);
+            db.busy_timeout(0);
+            int id1 = numOfRecords - 3;
+           
+            threadPool.runTask(createTask2(id1, dbFile.getPath(), tracker));
+            int id2 = numOfRecords + 3;
+            threadPool.runTask(createTask1(id2, dbFile.getPath(), tracker));
+            int oldID = 5;
+            int newID = 100;
+            threadPool.runTask(createTask3(oldID, dbFile.getPath(), newID,
+                    tracker));
+
+            threadPool.join();
+            
+            List<String> errors = tracker.getErrors();
+            assertTrue("No error occurred on DB but should have",errors.size() > 0);
+            
+            assertEquals(errors.get(0),
+            db.error_string(Constants.SQLITE_LOCKED));
+            assertEquals(errors.get(0), "database is locked");
+          
+            // reset
+
+            db.exec("delete from " + DatabaseCreator.TEST_TABLE1 + " where 1",
+                    null);
+            db.exec("delete from " + DatabaseCreator.TEST_TABLE3 + " where 1",
+                            null);
+            
+            // increase timeout for retry
+            db.busy_timeout(10000);
+            db.busy_handler(null);
+            tracker.reset();
+            threadPool = new ThreadPool(numThreads);
+            
+            threadPool.runTask(createTask1(id1, dbFile.getPath(), tracker));
+            threadPool.runTask(createTask2(id2, dbFile.getPath(), tracker));
+            
+            threadPool.join();
+            
+            errors = tracker.getErrors();
+            if (errors.size() > 0) {
+                fail("busy timeout should prevent from lock exception!");
+                for (String s: errors) {
+                    System.out.println("Round 2 Error"+s);
+                }
+            } else {
+                // ok
+            }
+            
+
+        } catch (Exception e) {
+            fail("Error in test setup " + e.getMessage());
+            try {
+                db.get_table("select * from " + DatabaseCreator.TEST_TABLE1,
+                        null).toString();
+            } catch (Exception e1) {
+
+                e1.printStackTrace();
+            }
+            e.printStackTrace();
+        } finally {
+            conn.setAutoCommit(true);
+            // cleanup
+            db.exec(DatabaseCreator.DROP_TABLE1, null);
+            db.exec(DatabaseCreator.DROP_TABLE3, null);
+        }
+    }
+
+    /**
+     * @tests {@link Database#get_table(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "get_table",
+        args = {java.lang.String.class}
+    )
+    public void testGet_tableString() {
+        TableResult emptyTable = new TableResult();
+        try {
+            //select from empty table
+            TableResult res = db.get_table("select * from "
+                    + DatabaseCreator.SIMPLE_TABLE1);
+            assertEquals(res.toString(), emptyTable.toString());
+            //fill table-> t
+//            DatabaseCreator.fillSimpleTable1(conn);
+//            res = db.get_table("select * from "
+//                    + DatabaseCreator.SIMPLE_TABLE1);
+//            assertFalse(emptyTable.toString().equals(res.toString()));
+            
+            try {
+                db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                        + " VALUES(1, 10, 20)", null);
+                res = db.get_table("select * from " + DatabaseCreator.SIMPLE_TABLE1);
+                db
+                        .exec("delete from " + DatabaseCreator.SIMPLE_TABLE1
+                                + " where 1", null);
+            } catch (Exception e) {
+                fail("Database error");
+                e.printStackTrace();
+            }
+            String row[] = (String[]) res.rows.elementAt(0);
+            assertEquals(Integer.parseInt(row[0]), 1);
+            assertEquals(Integer.parseInt(row[1]), 10);
+            assertEquals(Integer.parseInt(row[2]), 20);
+        } catch (Exception e) {
+            fail("Error getting table " + e.getMessage());
+            e.printStackTrace();
+//        } catch (SQLException e) {
+//            fail("Error initialising table " + e.getMessage());
+//            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @tests {@link Database#get_table(String, String[])}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "get_table",
+        args = {java.lang.String.class, java.lang.String[].class}
+    )
+    public void testGet_tableStringStringArray() {
+        String args[] = new String[1];
+        args[0] = "table";
+        String argsFail[] = new String[1];
+        try {
+            TableResult res = db.get_table(
+                    "select name from sqlite_master where type = ", argsFail);
+            fail("Testmethod should fail");
+        } catch (Exception e) {
+            try {
+                TableResult res = db.get_table(
+                        "select name from sqlite_master where type = '%q'",
+                        args);
+                String[] s = (String[]) res.rows.elementAt(0);
+                assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1);
+            } catch (Exception e2) {
+                fail("Testmethod failed: " + e2.getMessage());
+                e.printStackTrace();
+            }
+        }
+
+    }
+
+    /**
+     * @tests {@link Database#get_table(String, String[], TableResult)}
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "get_table",
+            args = {java.lang.String.class, java.lang.String[].class, TableResult.class}
+        ),
+        @TestTargetNew(
+                level = TestLevel.COMPLETE,
+                notes = "method test",
+                method = "toString",
+                clazz = TableResult.class,
+                args = {}
+            ),
+       @TestTargetNew(
+                    level = TestLevel.COMPLETE,
+                    notes = "method test",
+                    method = "types",
+                    clazz = TableResult.class,
+                    args = {String[].class}
+            ),
+       @TestTargetNew(
+                level = TestLevel.COMPLETE,
+                notes = "method test",
+                method = "TableResult",
+                clazz = TableResult.class,
+                args = {}
+           ),
+       @TestTargetNew(
+               level = TestLevel.NOT_NECESSARY,
+               notes = "method test",
+               method = "columns",
+               clazz = TableResult.class,
+               args = {String[].class}
+          ),
+      @TestTargetNew(
+              level = TestLevel.NOT_NECESSARY,
+              notes = "method test",
+              method = "newrow",
+              clazz = TableResult.class,
+              args = {String[].class}
+         ),
+     @TestTargetNew(
+         level = TestLevel.NOT_NECESSARY,
+         notes = "method test",
+         method = "clear",
+         clazz = TableResult.class,
+         args = {}
+        )
+     
+    })
+    public void testGet_tableStringStringArrayTableResult() {
+        String args[] = new String[1];
+        String argsFail[] = new String[1];
+        TableResult res = new TableResult();
+        TableResult defaultTableRes = new TableResult();
+        args[0] = "table";
+
+        try {
+            db.get_table("select name from sqlite_master where type = '%q'",
+                    argsFail, res);
+            assertEquals(defaultTableRes.toString(), res.toString());
+        } catch (Exception e) {
+            try {
+                db.get_table(
+                        "select name from sqlite_master where type = '%q'",
+                        args, res);
+                String[] s = (String[]) res.rows.elementAt(0);
+                assertEquals(s[0], DatabaseCreator.SIMPLE_TABLE1);
+                String[] types = res.types;
+                System.out
+                        .println("DatabaseTest.testGet_tableStringStringArrayTableResult() "+types.toString());
+            } catch (Exception e2) {
+                fail("Testmethod failed: " + e2.getMessage());
+                e.printStackTrace();
+            }
+        }
+    }
+
+    
+    /**
+     * @tests {@link Database#complete(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "complete",
+        args = {java.lang.String.class}
+    )
+    public void testComplete() {
+        assertFalse(db.complete("create"));
+        assertTrue(db.complete("create table TEST (res double);"));
+    }
+
+    /**
+     * @tests {@link Database#version()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "version",
+        args = {}
+    )
+    public void testVersion() {
+        String version = db.version();
+        if (version != null) {
+        assertTrue(Integer.parseInt(db.version().substring(0,1)) > 0);
+        assertEquals(db.version(), db.version());
+        } else {
+            fail("DB version info missing");
+        }
+        
+    }
+
+    /**
+     * @tests {@link Database#dbversion()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "dbversion",
+        args = {}
+    )
+    public void testDbversion() {
+        String verNo = "";
+        try {
+            verNo = db.dbversion();
+            db.close();
+            assertEquals(db.dbversion(),"unknown");
+            db.open(dbFile.getPath(), 0);
+            assertEquals(verNo,db.dbversion());
+        } catch (Exception e) {
+            try {
+                db.open(dbFile.getPath(), 0);
+            } catch (Exception e1) {
+                fail("error in db setup "+e.getMessage());
+                e.printStackTrace();
+            }
+            fail("error in db setup "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        assertTrue(Integer.parseInt(verNo.substring(0, 1))>= 3 );
+     
+    }
+
+    /**
+     * @tests {@link Database#create_function(String, int, Function)}
+     */
+    @TestTargets({
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "create_function",
+        args = {java.lang.String.class, int.class, Function.class}
+    ),
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "create_function",
+        args = {java.lang.String.class, int.class, Function.class}
+        )
+    })
+    public void testCreate_function() {
+        try {
+            double input = 1.0;
+            db.exec("create table TEST (res double)", null);
+            db.exec("insert into TEST values (" + Double.toString(input) + ")",
+                    null);
+            TableResult res = new TableResult();
+            Function sinFunc = (Function) new SinFunc();
+            db.create_function("sin", 1, sinFunc);
+            db.exec("select sin(res) from TEST WHERE res = "
+                    + Double.toString(input), res);
+            String row[] = (String[]) res.rows.elementAt(0);
+            String val = row[0];
+            double sinusVal = Double.parseDouble(val);
+            double funcVal = Math.sin(input);
+
+            assertTrue(Math.round(funcVal) == Math.round(sinusVal));
+        } catch (Exception e) {
+            fail("Error happened creating function:" + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @tests {@link Database#create_aggregate(String, int, Function)}
+     */
+    @TestTargets({
+            
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "create_aggregate",
+        args = {java.lang.String.class, int.class, Function.class}
+    ),
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "step",
+        clazz = Function.class,
+        args = {FunctionContext.class, String[].class}
+            ),
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "last_step",
+        clazz = Function.class,
+        args = {FunctionContext.class}
+                ),
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "function",
+        clazz = Function.class,
+        args = {FunctionContext.class, String[].class}
+                    )
+    })
+    public void testCreate_aggregate() {
+        TestTrace t = new TestTrace();
+        
+        MockFunction aggFunction = new MockFunction();
+       
+        try {
+            db
+                    .exec(
+                            "create table TEST(id integer, firstname text, lastname text)",
+                            null);
+            db.exec("insert into TEST values(3, 'James', 'Bond'); ", null);
+            db.exec("insert into TEST values(4, 'Fiona', 'Apple'); ", null);
+            db.trace((Trace) t);
+            db.create_aggregate("myaggfunc", 1, aggFunction);
+            db.function_type("myaggfunc", Constants.SQLITE_TEXT);
+            db.exec("PRAGMA show_datatypes = on", null);
+            
+            assertFalse(aggFunction.functionCalled);
+            assertFalse(aggFunction.stepCalled);
+            assertFalse(aggFunction.lastStepCalled);
+            db.exec("select myaggfunc(TEST.firstname) from TEST", t);
+            assertTrue(aggFunction.stepCalled);
+            assertTrue(aggFunction.lastStepCalled);
+            assertTrue(aggFunction.functionCalled);
+            
+            assertEquals("James Fiona ",aggFunction.getAggValue());
+            db.exec("drop table TEST", null);
+        } catch (Exception e) {
+            System.out.println(t.getTrace());
+            fail("Error in test setup: " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            db.create_aggregate("myaggfunc", 0, null);
+        } catch (Throwable e) {
+            assertEquals("null SQLite.Function not allowed",e.getMessage());
+        }
+            
+          try {
+            db.create_aggregate("myaggfunc", 0, aggFunction);
+        } catch (Throwable e) {
+            assertEquals("wrong number of arguments to function myaggfunc()",e.getMessage());
+        }
+        
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Database#function_type(String, int)}
+     * This method does not make sense
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Method does not make sense: for functions, return type is already set.",
+        method = "function_type",
+        args = {java.lang.String.class, int.class}
+    )
+    public void testFunction_type() throws Exception {
+        
+        double input = 1.0;
+        TableResult res = new TableResult();
+        Function sinFunc = (Function) new SinFunc();
+        
+        db.exec("PRAGMA show_datatypes = on", null);
+        db.exec("create table TEST (res double)", null);
+        db.exec("insert into TEST values (" + Double.toString(input) + ")",
+                null);
+        
+        db.create_function("sin", 1, sinFunc);
+        db.function_type("sin", Constants.SQLITE_NUMERIC);
+        res = db.get_table("select sin(res) from TEST WHERE res = "
+                + Double.toString(input));
+         
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+        assertTrue("double".equalsIgnoreCase(res.types[0]));
+        assertSame(Math.round(Math.sin(input)), Math.round(Double.parseDouble(val)));
+        
+        // function determines return type: test that Double type is returned.
+        db.function_type("sin", Constants.SQLITE_BLOB);
+        Stmt s = db.prepare("select sin(res) from TEST WHERE res = ?");
+        s.bind(1,input);
+        s.step();
+        
+        res = db.get_table("select sin(res) from TEST WHERE res = "
+                + Double.toString(input));
+        assertTrue("double".equalsIgnoreCase(res.types[0]));
+        row = (String[]) res.rows.elementAt(0);
+        val = row[0]; 
+        assertSame(Math.round(Math.sin(input)), Math.round(Double.parseDouble(val)));
+        
+
+        
+
+    }
+
+    /**
+     * @tests {@link Database#last_error()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "last_error",
+        args = {}
+    )
+    public void testLast_error() {
+        assertEquals(db.last_error(), Constants.SQLITE_OK);
+        try {
+            db.exec("create table TEST (res double)",null);
+            db.exec("create table TEST (res double)",null);
+            fail("Error should have happened");
+        } catch (Exception e) {
+            assertEquals(db.last_error(),db.last_error());
+            assertEquals(db.last_error(),Constants.SQLITE_ERROR);         
+        }
+       
+    }
+
+    /**
+     * @tests {@link Database#set_last_error(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "don't now which other errors may occur from black-box approach.",
+        method = "set_last_error",
+        args = {int.class}
+    )
+    public void testSet_last_error() {
+       assertEquals(db.last_error(), Constants.SQLITE_OK);
+       
+       try {
+           db.exec("sel from test;", null);
+       } catch (Exception e) {
+           assertEquals(Constants.SQLITE_ERROR,db.last_error());
+       }
+    }
+
+    /**
+     * @tests {@link Database#error_message()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "error_message",
+        args = {}
+    )
+    public void testError_message() {
+        String statement = "create table TEST (res double)";
+        try {
+            db.exec(statement,null);
+            db.exec(statement,null);
+            fail("DB Error expected");
+        } catch (Exception e) {
+            String dbError = db.error_message();
+            assertTrue(e.getMessage().equals(dbError)); 
+            
+        }
+    }
+
+    /**
+     * @tests {@link Database#error_string(int)}
+     */
+    
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "error_string",
+        args = {int.class}
+    )
+    public void testError_string() {
+        TestTrace t = new TestTrace();
+        assertEquals(db.last_error(), Constants.SQLITE_OK);
+        String errorString = db.error_string(Constants.SQLITE_ERROR);
+        try {
+            db.trace((Trace) t);
+            db.exec("create table TEST (res double)", t);
+            db.exec("create table TEST (res double)", t);
+        } catch (Exception e) {
+            assertEquals(db.last_error(), Constants.SQLITE_ERROR);
+            if (db.is3()) {
+                assertEquals("Unsupported Method (sqlite 3): error_string", db
+                        .error_string(db.last_error()), errorString);
+            }
+        }
+    }
+
+    /**
+     * @throws UnsupportedEncodingException 
+     * @tests {@link Database#set_encoding(String)}
+     * Method unsupported? -> tests fail
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test fails.",
+        method = "set_encoding",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("ASCII encoding does not work: a UTF encoded val is returned. Spec is not sufficient. "
+            + "Might be that test impl is wrong or String constructor for the ASCII encoding.")
+    public void testSet_encoding() throws UnsupportedEncodingException {
+        String input = "\u00bfMa\u00f1ana\u003f"; // ?Manana?
+        TableResult res = new TableResult();
+        String refOutput = null;
+        Stmt stat = null;
+
+        // DB setup
+        try {
+            db.exec("create table encodingTest (encoded text DEFAULT NULL);",
+                    null);
+            stat = db
+                    .prepare("insert into encodingTest(encoded) values(:one);");
+            stat.bind(1, input);
+            stat.step();
+            // stat.close();
+            db.exec("select * from encodingTest;", res);
+            String[] encInput = (String[]) res.rows.elementAt(0);
+            String output = encInput[0];
+            assertEquals(input, output);
+            // db.exec("delete from encodingTest where 1", null);
+        } catch (Exception e1) {
+            fail("Error in test setup: " + e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+     // tests for different encoding schemes
+        String[] charsetNames = {"UTF-8", "UTF-16", "UTF-16BE", "UTF-16LE"};
+        for (int i = 0; i < charsetNames.length; i++) {
+            try {
+                byte[] encInput = input.getBytes(charsetNames[i]);
+                db.set_encoding(charsetNames[i]);
+                db.exec("select * from encodingTest;", res);
+                String[] encOutput = (String[]) res.rows.elementAt(0);
+                String inputAsString = new String(encInput,charsetNames[i]);
+                assertEquals(inputAsString, encOutput[0]);
+            } catch (Exception e4) {
+                fail("Error setting the encoding." + e4.getMessage());
+                e4.printStackTrace();
+            } catch (UnsupportedEncodingException e2) {
+                fail(e2.getMessage());
+                e2.printStackTrace();
+            }
+        }
+
+        // Default tests
+        try {
+            db.set_encoding("UTF-16");
+            db.exec("select * from encodingTest;", res);
+            String[] encOutput1 = (String[]) res.rows.elementAt(0);
+            assertEquals("Got "+encOutput1[0]+" as UTF-16",input,encOutput1[0]);
+
+            db.set_encoding("US-ASCII");
+            db.exec("select * from encodingTest;", res);
+            String[] encOutput2 = (String[]) res.rows.elementAt(0);
+            assertEquals(new String(input.getBytes(),"US-ASCII"),encOutput2[0]);
+        } catch (Exception e) {
+            fail("Error setting the encoding." + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        
+        // DB teardown
+        try {
+            stat.close();
+            db.exec("delete from encodingTest", null);
+            // reset encoding
+        } catch (Exception e3) {
+            fail("Error in teardown of encoding environment");
+            e3.printStackTrace();
+        }
+        
+        // Default tests
+        try {
+            db.set_encoding("");
+            fail("invalid input should fail");
+        } catch (Exception e) {
+            //ok
+        }
+
+    }
+
+    /**
+     * Test fails -> implemented correctly?
+     * @tests {@link Database#set_authorizer(Authorizer)}
+     */
+    @TestTargets({
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test fails.",
+        method = "set_authorizer",
+        args = {Authorizer.class}
+    ),
+    @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test fails.",
+            method = "authorize",
+            clazz = Authorizer.class,
+            args = {int.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+        )
+    })
+    @KnownFailure("Callback never made for authorization. "+
+            "Results of private table are returned withouth furhter checks.")
+    public void testSet_authorizer() {
+        
+        TableResult resPriv = null;
+        TableResult resPub = null;
+        TableResult emptyTable = new TableResult();
+        String insertPublic = "insert into public_table values(1,2)";
+        String insertPrivate = "insert into private_table values(1,2)";
+        try {
+            // prepare, authorizer is not activated yet
+            db.exec("create table public_table(c1 integer, c2 integer);", null); 
+            db.exec("create table private_table(c1 integer, c2 integer);", null);
+            // inserts
+            db.exec(insertPublic, null);
+            db.exec(insertPrivate, null);
+            // selects
+            resPriv = db.get_table("select * from private_table");
+            resPub = db.get_table("select * from public_table");
+            
+//            db.exec("delete from public_table where 1", null);
+//            TableResult emptyPubTable = db.exec("select * from public");
+            
+            // set Authorizer (positive case): denies private table
+            AuthorizerCallback cb = new AuthorizerCallback();
+            db.set_authorizer(cb);
+            //select
+            
+            db.exec("select * from private_table", cb);
+            assertTrue(cb.wasCalled());
+            
+           /*
+            TableResult res = db.get_table("select * from private_table");
+            assertEquals(emptyTable.toString(),res.toString());
+            assertFalse(emptyTable.equals(resPriv));
+            
+            res = db.get_table("select * from public_table");
+            assertEquals(resPub,res);
+            */
+        } catch (Exception e) {
+            fail("Error testing authorization: "+e.getMessage());
+        }
+        
+        // Try insert
+        try {
+            db.exec(insertPublic, null);
+            fail("authorization failed");
+        } catch (Exception e) {
+            try {
+                db.exec(insertPrivate, null);
+                fail("authorization failed");
+            } catch (Exception e1) {
+                // ok
+            }
+        }
+        
+    }
+
+    /**
+     * @tests {@link Database#trace(Trace)}
+     */
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "trace",
+        args = {Trace.class}
+    )
+    public void testTrace() {
+        String stmt = "create table TEST (res double);";
+        TestTrace t = new TestTrace();
+        assertFalse(t.traceCalled);
+        assertEquals(db.last_error(),Constants.SQLITE_OK);
+        try {
+            db.trace((Trace) t);
+            db.exec(stmt,t);
+            assertTrue(t.traceCalled);
+            assertEquals(t.getTrace(),stmt);
+        } catch (Exception e) {
+            fail("Error testing traces: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            db.close();
+            db.exec(stmt,t);
+            fail("Exception Expected");
+        } catch (Exception e) {
+            //ok
+        }
+        
+        
+    }
+
+    /**
+     * @tests {@link Database#compile(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "compile",
+        args = {java.lang.String.class}
+    )
+    public void testCompileString() {
+        try {
+            db.compile("select name from sqlite_master;");
+        } catch (Exception e) {
+            fail("Error compiling sql statement " + e.getMessage());
+            e.printStackTrace();
+        }
+        try {
+            db.compile("test");
+            fail("Compiling of inaccurate statement does not fail.");
+        } catch (Exception e) {
+            
+        } 
+    }
+
+    /**
+     * @tests {@link Database#compile(String, String[])}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "compile",
+        args = {java.lang.String.class, java.lang.String[].class}
+    )
+    public void testCompileStringStringArray() {
+        String args[] = new String[1];
+        args[0] = "table";
+        try {
+            db.compile("select name from sqlite_master where type = '%q';",args);
+        } catch (Exception e) {
+            fail("Error compiling sql statement " + e.getMessage());
+            e.printStackTrace();
+        }
+        try {
+            db.compile("test",null);
+            fail("Compiling of inaccurate statement does not fail.");
+        } catch (Exception e) {
+            
+        } 
+    }
+
+    /**
+     * @tests {@link Database#prepare(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "prepare",
+        args = {java.lang.String.class}
+    )
+    public void testPrepare() {
+        Stmt st = null;
+        Stmt st2 = null;
+        // test empty statement
+        try {
+            st = db.prepare("");
+            assertEquals(0, st.bind_parameter_count());
+            st.step();
+            fail("stmt should not be prepared");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+
+        // test statement with unbound arguments
+        try {
+            st2 = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertEquals(3, st2.bind_parameter_count());
+            assertEquals(3, st2.bind_parameter_index(":three"));
+            assertEquals(":two", st2.bind_parameter_name(2));
+        } catch (Exception e) {
+            fail("error in prepare method: " + e.getMessage());
+            e.printStackTrace();
+        } finally {
+            try {
+                st2.close();
+            } catch (Exception e) {
+                fail("error in prepare method cleanup: " + e.getMessage());
+                e.printStackTrace();
+            }
+        }
+
+        try {
+            db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values(:one,:two,:three,:four);");
+        } catch (Exception e) {
+            assertEquals("table " + DatabaseCreator.SIMPLE_TABLE1
+                    + " has 3 columns but 4 values were supplied", e
+                    .getMessage());
+        }
+
+        try {
+            db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values(5, '10, 20);");
+        } catch (Exception e) {
+            assertEquals("unrecognized token: \"'10, 20);\"", e.getMessage());
+        }
+
+        try {
+            db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values(5, 10 20);");
+        } catch (Exception e) {
+            assertEquals("near \"20\": syntax error", e.getMessage());
+        }
+
+    }
+
+    /**
+     * @throws Exception 
+     * @throws java.lang.Exception 
+     * @tests {@link Database#open_blob(String, String, String, long, boolean)}
+     * unsupported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "open_blob",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, long.class, boolean.class}
+    )
+    @KnownFailure("not supported")
+    public void testOpen_blob() throws Exception, java.lang.Exception {
+        Stmt statement2;
+        Blob blobInput = new Blob();
+       
+        
+        // Create test input Blob
+        InputStream inStream = null;
+        byte[] in = {(byte) 1, (byte) 2, (byte) 3, (byte) 4};
+        
+        // setup test input
+        db.exec("create table TEST (res blob)",null);
+        inStream = Class.forName(this.getClass().getName()).getResourceAsStream("/blob.c");
+        assertNotNull(inStream);
+
+        
+        // insert byte array in db
+        try {
+            statement2 = db.prepare("insert into TEST(res) values (?)");
+            statement2.bind(1, in);
+            statement2.step();
+            statement2.close();
+        } catch (Exception e) {
+            fail("Error happened inserting blob" + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        // read from db
+        byte[] output = null;
+        Blob blob;
+       
+            blob = db.open_blob(dbFile.getPath(), "TEST", "res", 1, true);
+            if (blob == null) {
+                fail("Blob could not be retrieved");
+            }
+            //read from blob and compare values (positive case)
+            InputStream is = blob.getInputStream();
+            
+            int i = 0;
+            int outByte = 0;
+            byte[] out = new byte[4];
+            while ((outByte = is.read()) > -1) {
+                out[i] = (byte) outByte;
+                i++;
+            }
+            is.close();
+            
+            blob.close();
+            
+            assertTrue(Arrays.equals(in, out));
+            
+            //read from blob and compare values (default blob)
+            db.exec("insert into TEST values(zeroblob(128))", null);
+            Blob blob2 = db.open_blob(dbFile.getPath(), "TEST", "res", 2, true);
+            is = blob2.getInputStream();
+            for (i = 0; i < 128; i++)  {
+               assertEquals(0, is.read());
+            }
+            is.close();
+    }
+
+    /**
+     * @tests {@link Database#is3()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "is3",
+        args = {}
+    )
+    public void testIs3() {
+        int ver = Integer.parseInt(db.version().substring(0,1));
+        if (db.is3()) {
+            assertTrue( ver == 3);
+        } else {
+            assertTrue(ver != 3);
+        }
+    }
+
+    /**
+     * @tests {@link Database#progress_handler(int, ProgressHandler)}
+     */
+    @TestTargets ({
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "progress_handler",
+        args = {int.class, ProgressHandler.class}
+    ),
+    @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "progress",
+            clazz = ProgressHandler.class,
+            args = {}
+        )
+    })
+    public void testProgress_handler() {
+        int inputVal = 3;
+        TestProgressHandler prog = new TestProgressHandler();
+        try {
+            db.exec("create table TEST5(id integer, firstname text, lastname text)",null);
+            Vm vm = db.compile("select * from TEST5; "
+                    + "insert into TEST5 values(3, 'James', 'Bond'); "
+                    + "delete from TEST5 where id = 3; "
+                    + "select * from TEST5");
+            int stmt = 0;
+            do {
+                ++stmt;
+                if (stmt > inputVal) {
+                    db.progress_handler(inputVal, prog);
+                } else {
+                    assertEquals(0, prog.getCounts());
+                }
+                while (vm.step(prog)) {
+                }
+            } while (vm.compile());
+            assertEquals(inputVal,prog.getCounts());
+        } catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        // Boundary value test
+        inputVal = 0;
+        TestProgressHandler progBoundary = new TestProgressHandler();
+        db.progress_handler(inputVal, progBoundary);
+        try {
+        Vm vm2 = db.compile("select * from TEST5; "
+                + "insert into TEST5 values(3, 'James', 'Bond'); "
+                + "delete from TEST5 where id = 3; "
+                + "select * from TEST5");
+        do {
+            vm2.step(progBoundary);
+        } while (vm2.compile());
+        assertEquals(inputVal, progBoundary.getCounts());
+        }catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            db.exec("drop table TEST5",null);
+        } catch (Exception e) {
+            System.out.println(e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    
+    
+    class SinFunc implements Function {
+        
+        
+        public void function(FunctionContext fc, String args[]) {
+            Double d = new Double(args[0]);
+            fc.set_result(Math.sin(d.doubleValue()));
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+   @TestTargetClass(Trace.class)
+    class TestTrace implements Trace,Callback {
+       
+    private StringBuffer buf = new StringBuffer();
+    
+    public boolean traceCalled = false;
+    
+    public String getTrace() {
+        return buf.toString();
+    }
+    
+    public void trace(String stmt) {
+        traceCalled = true;
+        buf.append(stmt);
+    }
+
+    public void columns(String[] coldata) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    public boolean newrow(String[] rowdata) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    public void types(String[] types) {
+        // TODO Auto-generated method stub
+        
+    }
+   }
+   
+   @TestTargetClass(Authorizer.class)
+   class AuthorizerCallback implements Authorizer,Callback {
+       private boolean isAuthorizing = false;
+       
+       public boolean wasCalled() {
+           return isAuthorizing;
+       }
+
+    public int authorize(int action, String arg1, String arg2, String arg3,
+            String arg4) {
+        Logger.global.info("DB authorization callback "+action+" "+arg1+" "+arg2+" "+arg3+" "+arg4+" ");
+        this.isAuthorizing = true;
+        if (action != Constants.SQLITE_SELECT || arg1.contains("private_table")) {
+        return Constants.SQLITE_DENY;
+        } else {
+        return Constants.SQLITE_OK;
+        }
+    }
+
+    public void columns(String[] coldata) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    public boolean newrow(String[] rowdata) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    public void types(String[] types) {
+        // TODO Auto-generated method stub
+        
+    }
+       
+   }
+   
+   class TestBusyHandler implements BusyHandler, Callback {
+    
+    public boolean busy(String table, int count) {
+        System.out.println("BUSY!");
+        return true;
+    }
+
+    public void columns(String[] coldata) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    public boolean newrow(String[] rowdata) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    public void types(String[] types) {
+        // TODO Auto-generated method stub
+        
+    }
+       
+   }
+   
+   class TestProgressHandler implements ProgressHandler,Callback {
+       
+    private boolean progressed = false;
+    
+    private int counter = 0;
+       
+    public boolean isProgressed() {
+        return progressed;
+    }
+    
+    public int getCounts() {
+        return counter;
+    }
+
+    public boolean progress() {
+        this.progressed = true;
+        counter++;
+        return true;
+    }
+
+    public void columns(String[] coldata) {
+        // TODO Auto-generated method stub
+        
+    }
+
+    public boolean newrow(String[] rowdata) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    public void types(String[] types) {
+        // TODO Auto-generated method stub
+        
+    }
+       
+   }
+   
+//   class dbBusyThread implements Runnable {
+//       
+//       String dbName = "sqliteTest.db";
+//
+//       Thread runner;
+//       public dbBusyThread() {
+//       }
+//       public dbBusyThread(String threadName) {
+//           runner = new Thread(this, threadName); // (1) Create a new thread.
+//           System.out.println(runner.getName());
+//           runner.start(); // (2) Start the thread.
+//       }
+//       public void run() {
+//            insert(3000);
+//        }
+//       
+//       public void runNoDelay() {
+//           insert(0);
+//       }
+//       
+//       synchronized private void insert(long delay) {
+//           Database db2 = new Database();
+//           try {
+//               db2.open(dbName, 0);
+//               db2.exec("insert into TEST5 values (4,'Anglina','Jolie');",
+//                       null);
+//               wait(delay);
+//           } catch (Exception e) {
+//               System.out.println("Error in Thread " + e.getMessage());
+//               e.printStackTrace();
+//           } catch (InterruptedException e2) {
+//               System.out.println("Error in Thread " + e2.getMessage());
+//               e2.printStackTrace();
+//           } finally {
+//              try {
+//               db2.close();
+//           } catch (Exception e) {
+//               // We do not handle this case
+//           }
+//           }
+//       }
+//   }
+   
+   /**
+    * This method creates a Runnable that executes insert operation for the
+    * first table
+    */
+   private static Runnable createTask2Interrupt(final int id,
+            final String dbName, final ErrorTracker errorTracker) {
+        return new Runnable() {
+            public void run() {
+                Database db = new Database();
+                try {
+                    String value = DatabaseCreator.defaultString + id;
+
+                    db.open(dbName, 0);
+                    String insertQuery = "INSERT INTO "
+                            + DatabaseCreator.TEST_TABLE1
+                            + " (id, field1, field2, field3) VALUES(" + id
+                            + ", '" + value + "', " + id + ", " + id + ")";
+                    db.exec(insertQuery, null);
+                } catch (Exception e) {
+                    errorTracker.registerException(this, e);
+                    try {
+                        db.interrupt();
+                        db.exec("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE1
+                                + " WHERE id=" + id, null);
+                    } catch (Exception e1) {
+                        errorTracker.registerException(this, e1);
+                    }
+                }
+            }
+        };
+   }
+   
+   /**
+    * This method creates a Runnable that executes delete operation for the
+    * first table
+    */
+   private static Runnable createTask1(final int id,final String dbName, final ErrorTracker errorTracker) {
+       return new Runnable() {
+           public void run() {
+               try {
+                   Database db = new Database();
+                   db.open(dbName, 0);
+                   db.exec("DELETE FROM "
+                           + DatabaseCreator.SIMPLE_TABLE1 + " WHERE id=" + id,null);
+               } catch (Exception e) {
+                   errorTracker.registerException(this, e);
+               }
+           }
+       };
+   }
+   
+   /**
+    * This method creates a Runnable that executes insert operation for the
+    * first table
+    */
+   private static Runnable createTask2(final int id, final String dbName, final ErrorTracker errorTracker ) {
+       return new Runnable() {
+           public void run() {
+               try {
+                   String value = DatabaseCreator.defaultString + id;
+                   Database db = new Database();
+                   db.open(dbName, 0);
+                   String insertQuery = "INSERT INTO "
+                           + DatabaseCreator.TEST_TABLE1
+                           + " (id, field1, field2, field3) VALUES(" + id
+                           + ", '" + value + "', " + id + ", " + id + ")";
+                   db.exec(insertQuery,null);
+               } catch (Exception e) {  
+                   errorTracker.registerException(this, e);
+                   
+               }
+           }
+       };
+   }
+   
+   /**
+    * This method creates a Runnable that executes update operation for the one
+    * record of the first table
+    */
+   private static Runnable createTask3(final int oldID, final String dbName,
+            final int newID, final ErrorTracker errorTracker) {
+        return new Runnable() {
+            public void run() {
+                Database db = new Database();
+                try {
+                    db.open(dbName, 0);
+                    String value = DatabaseCreator.defaultString + newID;
+                    String updateQuery = "UPDATE "
+                            + DatabaseCreator.TEST_TABLE1 + " SET id=" + newID
+                            + ", field1='" + value + "', field2=" + newID
+                            + ", field3=" + newID + " WHERE id=" + oldID;
+                    db.exec(updateQuery, null);
+                } catch (Exception e) {
+                    errorTracker.registerException(this, e);
+                }
+            }
+        };
+    }
+   
+   private class ErrorTracker {
+        private List<String> errors = new ArrayList<String>();
+
+        public void registerException(Runnable runnable, Exception e) {
+            System.out.println("Registered: "+e.getMessage());
+            errors.add(e.getMessage());
+        }
+
+        public List<String> getErrors() {
+            return errors;
+        }
+        
+        public void reset() {
+            errors.clear();
+        }
+    }
+   
+}
+
diff --git a/sql/src/test/java/tests/SQLite/ExceptionTest.java b/sql/src/test/java/tests/SQLite/ExceptionTest.java
new file mode 100644
index 0000000..fe86e8f
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/ExceptionTest.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Database;
+import SQLite.Exception;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+@TestTargetClass(SQLite.Exception.class)
+public class ExceptionTest extends SQLiteTest {
+    
+    private Database db = null;
+
+    public void setUp() throws java.lang.Exception {
+        super.setUp();
+        db = new Database();
+    }
+    
+    public void tearDown() {
+        super.tearDown();
+    }
+    
+    /**
+     * @tests {@link Exception#Exception(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "constructor test",
+        method = "Exception",
+        args = {java.lang.String.class}
+    )
+    public void testException() {
+        try {
+            db.open(dbFile.getName(), 0);
+        } catch (Exception e) {
+            assertNotNull(e);
+            assertNotNull(e.getMessage());
+        }
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/FunctionContextTest.java b/sql/src/test/java/tests/SQLite/FunctionContextTest.java
new file mode 100644
index 0000000..1bb5cf5
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/FunctionContextTest.java
@@ -0,0 +1,452 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Database;
+import SQLite.Exception;
+import SQLite.Function;
+import SQLite.FunctionContext;
+import SQLite.Stmt;
+import SQLite.TableResult;
+import dalvik.annotation.AndroidOnly;
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.io.UnsupportedEncodingException;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import tests.support.DatabaseCreator;
+
+@TestTargetClass(FunctionContext.class)
+public class FunctionContextTest extends SQLiteTest {
+    
+    private Database db = null;
+
+    public void setUp() throws java.lang.Exception {
+        Statement st = null;
+        super.setUp();
+        db = new Database();
+        db.open(dbFile.getPath(), 0);
+        st = conn.createStatement();
+        st.execute(DatabaseCreator.CREATE_TABLE2);
+        st.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
+        st.close();
+    }
+
+    /* (non-Javadoc)
+     * @see junit.framework.TestCase#tearDown()
+     */
+    public void tearDown() {
+        super.tearDown();
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_result(java.lang.String)}.
+     * @throws Exception 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "indirectly tested invoking function",
+        method = "set_result",
+        args = {java.lang.String.class}
+    )
+    public void testSet_resultString() throws Exception {
+        TestFCString testString = new TestFCString();
+        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
+                + " (ftext) values ('TestInput')", null);
+        db.create_function("test", 1, testString);
+        TableResult res = db.get_table("select test(ftext) from "
+                + DatabaseCreator.TEST_TABLE2);
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+
+        assertEquals("TestInput", val);
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_result(int)}.
+     * @throws Exception 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "method test",
+        method = "set_result",
+        args = {int.class}
+    )
+    public void testSet_resultInt() throws Exception {
+        TestFCInt testInt = new TestFCInt();
+        db.exec("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                + "  values (1,'" + testInt.intVal + "',3)", null);
+        db.create_function("testInt", 1, testInt);
+        TableResult res = db.get_table("select testInt(speed) from "
+                + DatabaseCreator.SIMPLE_TABLE1);
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+
+        assertEquals(testInt.intVal, Integer.parseInt(val));
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_result(double)}.
+     * @throws Exception 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "indirectly tested",
+        method = "set_result",
+        args = {double.class}
+    )
+    public void testSet_resultDouble() throws Exception {
+        SinFunc testD = new SinFunc();
+        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
+                + " (fdouble)  values (" + testD.testDouble + ")", null);
+        db.create_function("testDouble", 1, testD);
+        TableResult res = db.get_table("select testDouble(fdouble) from "
+                + DatabaseCreator.TEST_TABLE2);
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+
+        assertEquals(testD.testDouble, Double.parseDouble(val));
+        
+        assertTrue(testD.functionCalled);
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_error(java.lang.String)}.
+     * @throws Exception 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "set_error",
+        args = {java.lang.String.class}
+    )
+    public void testSet_error() throws Exception {
+        TestFCError testError = new TestFCError();
+        SinFunc testD = new SinFunc();
+        db.exec("insert into " + DatabaseCreator.TEST_TABLE2
+                + " (fdouble)  values (" + testD.testDouble + ")", null);
+        db.create_function("testError", 1, testError);
+        
+        try {
+        TableResult res = db.get_table("select testError(fdouble) from "
+                + DatabaseCreator.TEST_TABLE2);
+        fail("Should get Exception");
+        } catch (Exception e) {
+            assertEquals("error in step", e.getMessage());
+        }
+        
+        assertFalse(testD.functionCalled);
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_result(byte[])}.
+     * @throws Exception 
+     * @throws UnsupportedEncodingException 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "set_result",
+        args = {byte[].class}
+    )
+    public void testSet_resultByteArray() throws Exception, UnsupportedEncodingException {     
+        Stmt st = null;
+        TestFCByteArray testBinArrayFnc = new TestFCByteArray();
+        String expected = "";
+        expected = "X'" + getHexString(testBinArrayFnc.byteVal) + "'";
+        
+        // setup
+        db.exec("create table testBinaryData (binVal BINARY) ;", null);
+        
+        try {
+        st = db.prepare("insert into testBinaryData values (?)");
+        st.bind(1, testBinArrayFnc.byteVal);
+        st.step();
+
+
+        db.create_function("testBinArray", 1, testBinArrayFnc);
+        TableResult res = db
+                .get_table("select testBinArray(binVal) from testBinaryData");
+
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+       
+        assertTrue(expected.equalsIgnoreCase(val));
+        
+        assertTrue(testBinArrayFnc.functionCalled);
+        
+        } finally {
+            //teardown
+            db.exec("drop table testBinaryData;", null);
+        }
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#set_result_zeroblob(int)}.
+     * @throws Exception 
+     * @throws UnsupportedEncodingException 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "set_result_zeroblob",
+        args = {int.class}
+    )
+    public void testSet_result_zeroblob() throws Exception,
+            UnsupportedEncodingException {
+        Stmt st = null;
+        TestFCZeroBlob testZeroBlobFnc = new TestFCZeroBlob();
+        byte[] byteVal = {(byte) 1, (byte) 2, (byte) 3};
+        
+        
+        // setup
+        db.exec("create table testBinaryData (binVal BINARY) ;", null);
+        
+        try {
+        st = db.prepare("insert into testBinaryData values (?)");
+        st.bind(1, byteVal);
+        st.step();
+
+
+        db.create_function("testZeroBlob", 0, testZeroBlobFnc);
+        TableResult res = db
+                .get_table("select testZeroBlob() from testBinaryData");
+        TableResult res2 = db.get_table("select zeroblob("
+                + testZeroBlobFnc.numBytes + ") from testBinaryData");
+
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+
+        assertNotNull(val);
+
+        assertEquals(((String[]) res2.rows.elementAt(0))[0], val);
+        assertTrue(testZeroBlobFnc.functionCalled);
+        
+        } finally  {
+         // teardown
+            db.exec("drop table if exists testBinaryData;", null);
+        }
+    }
+
+    /**
+     * Test method for {@link SQLite.FunctionContext#count()}.
+     * @throws SQLException 
+     * @throws Exception 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "count",
+        args = {}
+    )
+    @AndroidOnly("Test Method results in a segmentation fault.")
+    public void testCount() throws SQLException, Exception {
+        TestFCCount countTest = new TestFCCount();
+        int inputCount = 10;
+        
+        assertFalse(countTest.functionCalled);
+        
+        DatabaseCreator.fillTestTable2(conn, inputCount);
+        db.create_function("testCount", 0, countTest);
+        // the invokation of testCount leads to a Segmentation fault
+        /*
+        TableResult res = db
+                .get_table("select testCount() from "+DatabaseCreator.TEST_TABLE2);
+       
+        String row[] = (String[]) res.rows.elementAt(0);
+        String val = row[0];
+        
+        assertTrue(countTest.functionCalled);
+        assertEquals(inputCount,Integer.parseInt(val));
+        */
+        
+    }
+    
+    class TestFCError implements Function {
+        public boolean functionCalled = false;
+        public String errorMsg = "FunctionError";
+        
+        public void function(FunctionContext fc, String args[]) {
+            functionCalled = true;
+            fc.set_error(errorMsg);
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    class TestFCCount implements Function {
+        public boolean functionCalled = false;
+        public int noOfRows = 0;
+        
+        public void function(FunctionContext fc, String args[]) {
+            functionCalled = true;
+            noOfRows = fc.count();
+            fc.set_result(noOfRows);
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    class TestFCZeroBlob implements Function {
+        public int numBytes = 16;
+        public boolean functionCalled = false;
+        
+        public void function(FunctionContext fc, String args[]) {
+            functionCalled = true;
+            fc.set_result_zeroblob(numBytes);
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    class TestFCString implements Function {
+        public String testString = "TestString";
+        public boolean functionCalled;
+        
+        public void function(FunctionContext fc, String args[]) {
+            assertNotNull(args);
+            functionCalled = true;
+            fc.set_result(args[0]);
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    class TestFCInt implements Function {
+        public int intVal = Integer.MAX_VALUE;
+        public boolean functionCalled;
+        
+        public void function(FunctionContext fc, String args[]) {
+            assertNotNull(args);
+            functionCalled = true;
+            fc.set_result(Integer.parseInt(args[0]));
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    class TestFCByteArray implements Function {
+        public byte[] byteVal = {(byte)  1, (byte) 2, (byte) 3};
+        public boolean functionCalled;
+        
+        public void function(FunctionContext fc, String args[]) {
+            assertNotNull(args);
+            functionCalled = true;
+            fc.set_result(args[0].getBytes());
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+        class SinFunc implements Function {
+            
+        public Double testDouble = 3.0;
+        public boolean functionCalled = false;
+        
+        public void function(FunctionContext fc, String args[]) {
+            Double d = new Double(args[0]);
+            functionCalled = true;
+            fc.set_result(d.doubleValue());
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+    }
+    
+    static final byte[] HEX_CHAR_TABLE = {
+            (byte)'0', (byte)'1', (byte)'2', (byte)'3',
+            (byte)'4', (byte)'5', (byte)'6', (byte)'7',
+            (byte)'8', (byte)'9', (byte)'a', (byte)'b',
+            (byte)'c', (byte)'d', (byte)'e', (byte)'f'
+          };    
+
+     public static String getHexString(byte[] raw)
+            throws UnsupportedEncodingException {
+        byte[] hex = new byte[2 * raw.length];
+        int index = 0;
+
+        for (byte b : raw) {
+            int v = b & 0xFF;
+            hex[index++] = HEX_CHAR_TABLE[v >>> 4];
+            hex[index++] = HEX_CHAR_TABLE[v & 0xF];
+        }
+        return new String(hex, "ASCII");
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/JDBCDriverFunctionalTest.java b/sql/src/test/java/tests/SQLite/JDBCDriverFunctionalTest.java
new file mode 100644
index 0000000..ed2c0b3
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/JDBCDriverFunctionalTest.java
@@ -0,0 +1,110 @@
+/*
+ * 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.SQLite;
+
+import SQLite.Exception;
+import SQLite.JDBCDriver;
+import dalvik.annotation.TestTargetClass;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.SQLException;
+
+
+/**
+ * Tests the SQLite.JDBCDriver.
+ */
+@TestTargetClass(JDBCDriver.class)
+public class JDBCDriverFunctionalTest extends AbstractSqlTest {
+
+
+
+    /**
+     * The SQLite db file.
+     */
+    private  File dbFile = null;
+    
+    private String connectionURL = "empty";
+
+    /**
+     * Sets up an unit test by loading the SQLite.JDBCDriver, getting two
+     * connections and calling the setUp method of the super class.
+     * @throws Exception 
+     * @throws IllegalAccessException 
+     * @throws InstantiationException 
+     * @throws Exception 
+     * @throws Exception 
+     * @throws Exception 
+     * @throws Exception 
+     * @throws Exception 
+     */
+    @Override
+    public void setUp() throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException, Exception { // the Exception class needs to be fully
+        // qualified since there is an Exception
+        // class in the SQLite package.
+
+        super.setUp();
+    }
+
+    /**
+     * Tears down an unit test by calling the tearDown method of the super class
+     * and deleting the SQLite test db file.
+     */
+    @Override
+    protected void tearDown() throws SQLException {
+        super.tearDown();
+        dbFile.delete();
+    }
+
+
+    @Override
+    protected String getConnectionURL() {
+        if (connectionURL.equals("empty")) {
+            String tmp = System.getProperty("java.io.tmpdir");
+            File tmpDir = new File(tmp);
+            if (tmpDir.isDirectory()) {
+                try {
+                    dbFile = File.createTempFile("JDBCDriverFunctionalTest",
+                            ".db", tmpDir);
+                } catch (IOException e) {
+                    System.err.println("error creating temporary DB file.");
+                }
+                dbFile.deleteOnExit();
+            } else {
+                System.err.println("java.io.tmpdir does not exist");
+            }
+
+            connectionURL = "jdbc:sqlite:/" + dbFile.getPath();
+
+        }
+
+        return connectionURL;
+    }
+    
+    @Override
+    protected String getDriverClassName() {
+        return "SQLite.JDBCDriver";
+    }
+
+    @Override
+    protected int getTransactionIsolation() {
+        return Connection.TRANSACTION_SERIALIZABLE;
+    }
+    
+    
+}
diff --git a/sql/src/test/java/tests/SQLite/JDBCDriverTest.java b/sql/src/test/java/tests/SQLite/JDBCDriverTest.java
new file mode 100644
index 0000000..c6fd677
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/JDBCDriverTest.java
@@ -0,0 +1,272 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Exception;
+import SQLite.JDBCDriver;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
+
+import java.sql.Connection;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.DriverPropertyInfo;
+import java.sql.SQLException;
+
+
+@TestTargetClass(JDBCDriver.class)
+public class JDBCDriverTest extends JDBCDriverFunctionalTest {
+    
+    /**
+     * The SQLite db file.
+     */
+    private JDBCDriver jDriver;
+    
+    private Driver returnedDriver;
+
+    public void setUp() throws ClassNotFoundException, SQLException, InstantiationException, IllegalAccessException, Exception  {
+        
+        try {
+            super.setUp();
+            returnedDriver = DriverManager.getDriver(getConnectionURL());
+            if (returnedDriver instanceof JDBCDriver) {
+                this.jDriver = (JDBCDriver) returnedDriver;
+            }
+        } catch (SQLException e) {
+          System.out.println("Cannot get driver");
+            e.printStackTrace();
+        } catch (Exception e) {
+            System.out.println("DB Setup failed");
+            e.printStackTrace();
+        }
+   }
+
+    /**
+     * @tests JDBCDriver#JDBCDriver()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "constructor test",
+        method = "JDBCDriver",
+        args = {}
+    )
+    public void testJDBCDriver() {
+        assertTrue(returnedDriver instanceof JDBCDriver);
+    }
+
+    /**
+     * @tests JDBCDriver#acceptsURL(String)
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "constructor test",
+            method = "acceptsURL",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "constructor test",
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,
+            method = "acceptsURL",
+            args = {java.lang.String.class}
+        )        
+    })
+    public void testAcceptsURL() {
+        try {
+            if (this.jDriver != null) {
+                assertTrue(jDriver.acceptsURL(getConnectionURL()));
+            } else {
+                fail("no Driver available");
+            }
+        } catch (SQLException e) {
+            fail("Driver does not accept URL");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @tests JDBCDriver#connect(String, java.util.Properties)
+     */
+    @TestTargets({    
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "connect",
+            args = {java.lang.String.class, java.util.Properties.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,
+            notes = "method test",
+            method = "connect",
+            args = {java.lang.String.class, java.util.Properties.class}
+        )
+    })
+    public void testConnect() {
+        try {
+            if (this.jDriver != null) {
+                Connection c = jDriver.connect(getConnectionURL(), null);
+                assertFalse(c.isClosed());
+                DriverManager.getConnection(getConnectionURL());
+            } else {
+                fail("no Driver available");
+            }
+        } catch (SQLException e) {
+            fail("Driver does not connect");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * @tests JDBCDriver#getMajorVersion()
+     */
+   @TestTargets({    
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "getMajorVersion",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,
+            notes = "method test",
+            method = "getMajorVersion",
+            args = {}
+        )
+    })    
+    public void testGetMajorVersion() {
+        if (this.jDriver != null) {
+            assertTrue(jDriver.getMajorVersion() > 0);
+        } else {
+            fail("no Driver available");
+        }
+    }
+
+    /**
+     * @tests JDBCDriver#getMinorVersion()
+     */
+   @TestTargets({       
+       @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "getMinorVersion",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,            
+            method = "getMinorVersion",
+            args = {}
+        )
+   })
+   public void testGetMinorVersion() {
+        if (this.jDriver != null) {
+            assertTrue(jDriver.getMinorVersion() > 0);
+        } else {
+            fail("no version information available");
+        }
+    }
+
+    /**
+     * @tests JDBCDriver#getPropertyInfo(String, java.util.Properties)
+     */
+   @TestTargets({
+       @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "getPropertyInfo",
+            args = {java.lang.String.class, java.util.Properties.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,            
+            method = "getPropertyInfo",
+            args = {java.lang.String.class, java.util.Properties.class}
+        )
+   })
+   public void testGetPropertyInfo() {
+        DriverPropertyInfo[] info = null;
+        try {
+            if (this.jDriver != null) {
+                info = jDriver.getPropertyInfo(getConnectionURL(), null);
+                assertNotNull(info);
+                assertTrue(info.length > 0);
+            } else {
+                fail("no Driver available");
+            }
+        } catch (SQLException e) {
+            fail("Driver property details not available");
+            e.printStackTrace();
+        }
+        
+        assertNotNull(info);
+     
+    }
+
+    /**
+     * @tests JDBCDriver#jdbcCompliant()
+     */
+   @TestTargets({    
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "method test",
+            method = "jdbcCompliant",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            // we have to list the Driver target explicitly, since SQLite
+            // is not part of the target packages
+            clazz = Driver.class,
+            notes = "method test",
+            method = "jdbcCompliant",
+            args = {}
+        )
+    })        
+    public void testJdbcCompliant() {
+        if (this.jDriver != null) {
+            assertFalse(jDriver.jdbcCompliant());
+        } else {
+            fail("no version information available");
+        }
+    }
+    /**
+     * Tears down an unit test by calling the tearDown method of the super class
+     * and deleting the SQLite test db file.
+     */
+    @Override
+    protected void tearDown() throws SQLException {
+        super.tearDown();
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/SQLiteTest.java b/sql/src/test/java/tests/SQLite/SQLiteTest.java
new file mode 100644
index 0000000..0463dcb
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/SQLiteTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import junit.framework.TestCase;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.logging.Logger;
+
+public class SQLiteTest extends TestCase {
+    public static Connection conn;
+    public static File dbFile = null;
+    
+    public void setUp() throws Exception {
+        String tmp = System.getProperty("java.io.tmpdir");
+        File tmpDir = new File(tmp);
+        try {
+            if (tmpDir.isDirectory()) {
+                dbFile = File.createTempFile("sqliteTest", ".db", tmpDir);
+                dbFile.deleteOnExit();
+            } else {
+                System.out.println("ctsdir does not exist");
+            }
+            
+            Class.forName("SQLite.JDBCDriver").newInstance();
+
+            if (!dbFile.exists()) {
+              Logger.global.severe("DB file could not be created. Tests can not be executed.");
+            } else {
+            conn = DriverManager.getConnection("jdbc:sqlite:/"
+                    + dbFile.getPath());
+            }
+            assertNotNull("Error creating connection",conn);
+        } catch (IOException e) {
+            System.out.println("Problem creating test file in " + tmp);
+        } catch (SQLException e) {
+            // TODO Auto-generated catch block
+            fail("Exception: " + e.toString());
+        } catch (java.lang.Exception e) {
+            fail("Exception: " + e.toString());
+        }
+        
+    }
+    
+    public void tearDown() {
+        try {
+            if (!conn.isClosed()) {
+                conn.close();
+            }
+        } catch (SQLException e) {
+            fail("Couldn't close Connection: " + e.getMessage());
+        }
+
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/ShellTest.java b/sql/src/test/java/tests/SQLite/ShellTest.java
new file mode 100644
index 0000000..208341c
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/ShellTest.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Shell;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.io.PrintStream;
+import java.io.PrintWriter;
+
+@TestTargetClass(Shell.class)
+public class ShellTest extends TestCase {
+
+    /**
+     * Test method for {@link SQLite.Shell#Shell(java.io.PrintWriter, java.io.PrintWriter)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "Shell",
+      args = {PrintWriter.class, PrintWriter.class}
+    )
+    public void testShellPrintWriterPrintWriter() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#Shell(java.io.PrintStream, java.io.PrintStream)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "Shell",
+      args = {PrintStream.class, PrintStream.class}
+    )
+    public void testShellPrintStreamPrintStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#clone()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "clone",
+      args = {}
+    )
+    public void testClone() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#sql_quote_dbl(java.lang.String)}.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+                method = "sql_quote_dbl",
+                args = {String.class}
+          )
+    public void testSql_quote_dbl() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#sql_quote(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "sql_quote",
+          args = {String.class}
+    )
+    public void testSql_quote() {
+        fail("Not yet implemented");
+    }
+
+
+    /**
+     * Test method for {@link SQLite.Shell#columns(java.lang.String[])}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "columns",
+      args = {String[].class}
+    )
+    public void testColumns() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#types(java.lang.String[])}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "types",
+      args = {String[].class}
+    )
+    public void testTypes() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link SQLite.Shell#newrow(java.lang.String[])}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "newrow",
+      args = {String[].class}
+    )
+    public void testNewrow() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "main",
+      args = {String[].class}
+    )
+    public void testMain() {
+        
+    }
+
+}
diff --git a/sql/src/test/java/tests/SQLite/StmtTest.java b/sql/src/test/java/tests/SQLite/StmtTest.java
new file mode 100644
index 0000000..20f8221
--- /dev/null
+++ b/sql/src/test/java/tests/SQLite/StmtTest.java
@@ -0,0 +1,1271 @@
+/*
+ * Copyright (C) 2008 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.SQLite;
+
+import SQLite.Constants;
+import SQLite.Database;
+import SQLite.Exception;
+import SQLite.Stmt;
+import SQLite.TableResult;
+import dalvik.annotation.AndroidOnly;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import java.sql.Connection;
+import java.sql.SQLException;
+
+@TestTargetClass(Stmt.class)
+public class StmtTest extends SQLiteTest {
+    
+    private static Database db = null;
+    
+    private static Stmt st = null;
+    
+    private static final String createAllTypes = 
+    "create table type (" +
+
+    " BoolVal BOOLEAN," + " IntVal INT," + " LongVal LONG,"
+            + " Bint BIGINT," + " Tint TINYINT," + " Sint SMALLINT,"
+            + " Mint MEDIUMINT, " +
+
+            " IntegerVal INTEGER, " + " RealVal REAL, "
+            + " DoubleVal DOUBLE, " + " FloatVal FLOAT, "
+            + " DecVal DECIMAL, " +
+
+            " NumVal NUMERIC, " + " charStr CHAR(20), "
+            + " dateVal DATE, " + " timeVal TIME, " + " TS TIMESTAMP, "
+            +
+
+            " DT DATETIME, " + " TBlob TINYBLOB, " + " BlobVal BLOB, "
+            + " MBlob MEDIUMBLOB, " + " LBlob LONGBLOB, " +
+
+            " TText TINYTEXT, " + " TextVal TEXT, "
+            + " MText MEDIUMTEXT, " + " LText LONGTEXT, " + 
+            
+            " MaxLongVal BIGINT, MinLongVal BIGINT, "+
+            
+            " validURL URL, invalidURL URL "+
+            
+            ");";
+    
+    static final String insertAllTypes = 
+        "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,"
+        + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal,"
+        + "NumVal, charStr, dateVal, timeVal, TS,"
+        + "DT, TBlob, BlobVal, MBlob, LBlob,"
+        + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal,"
+        + " validURL, invalidURL"
+        + ") "
+        + "values (1, -1, 22, 2, 33,"
+        + "3, 1, 2, 3.9, 23.2, 33.3, 44,"
+        + "5, 'test string', '1799-05-26', '12:35:45', '2007-10-09 14:28:02.0',"
+        + "'1221-09-22 10:11:55', 1, 2, 3, 4,"
+        + "'Test text message tiny', 'Test text',"
+        + " 'Test text message medium', 'Test text message long', "
+        + Long.MAX_VALUE+", "+Long.MIN_VALUE+", "
+        + "null, null "+
+        ");";
+    
+    static final String allTypesTable = "type";
+    
+    public void setUp() throws java.lang.Exception {
+        super.setUp();
+        Support_SQL.loadDriver();
+        db = new Database();
+        db.open(dbFile.getPath(), 0);
+        db.exec(DatabaseCreator.CREATE_TABLE_SIMPLE1, null);
+        DatabaseCreator.fillSimpleTable1(conn);
+       
+    }
+
+    public void tearDown() {
+        if (st != null) {
+            try {
+            st.close();
+            } catch (Exception e) {
+                
+            }
+        }
+        try {
+            db.close();
+            Connection con = Support_SQL.getConnection();
+            con.close();
+//            dbFile.delete();
+        } catch (Exception e) {
+            fail("Exception in tearDown: "+e.getMessage());
+        } catch (SQLException e) {
+            fail("SQLException in tearDown: "+e.getMessage());
+        }
+        super.tearDown();
+    }
+    
+    /**
+     * @tests {@link Stmt#Stmt()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "constructor test",
+        method = "Stmt",
+        args = {}
+    )
+    public void testStmt() {
+        Stmt st = new Stmt();
+        assertNotNull(st);
+        try {
+            Stmt actual = db.prepare("");
+            assertNotNull(st);
+            // no black box test assertEquals(actual.error_code,st.error_code);
+        } catch (Exception e) {
+            fail("Statement setup fails: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+               st.step();
+               fail("Cannot execute non prepared Stmt");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#finalize()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "method test",
+        method = "finalize",
+        args = {}
+    )
+    public void testFinalize() {
+        
+    }
+
+    /**
+     * @tests {@link Stmt#prepare()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "prepare",
+        args = {}
+    )
+    public void testPrepare() {
+        try {
+            st = db.prepare("");
+            st.prepare();
+            fail("statement is closed");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+
+        try {
+            st = new Stmt();
+            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
+            assertFalse(st.prepare());
+            st = new Stmt();
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertFalse(st.prepare());
+            st = new Stmt();
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            st.bind(1, 1);
+            st.bind(2, 10);
+            st.bind(3, 30);
+            assertFalse(st.prepare());
+            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1
+                    + "; " + "delete from " + DatabaseCreator.SIMPLE_TABLE1
+                    + " where id = 5; " + "insert into "
+                    + DatabaseCreator.SIMPLE_TABLE1 + " values(5, 10, 20); "
+                    + "select * from " + DatabaseCreator.SIMPLE_TABLE1 + ";");
+            assertTrue(st.prepare());
+            assertTrue(st.prepare());
+            assertTrue(st.prepare());
+            assertFalse(st.prepare());
+        } catch (Exception e) {
+            fail("statement should be ready for execution: "
+                    + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#step()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "step",
+        args = {}
+    )
+    public void testStep() {
+        try {
+            st.step();
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+        
+        try {
+            st = new Stmt();
+            st = db.prepare("select name from sqlite_master where type = 'table'");
+            st.step();
+        } catch (Exception e) {
+           fail("test fails"); 
+        }
+        
+    }
+    
+    /**
+     * @tests {@link Stmt#close()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "close",
+        args = {}
+    )
+    public void testClose() {
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            st.close();
+        } catch (Exception e) {
+            fail("Test fails");
+            e.printStackTrace();
+        }
+        
+        try {
+            st.step();
+            fail("Test fails");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+    }
+    
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#reset()}
+     */
+    @TestTargetNew(
+        level = TestLevel.TODO,
+        notes = "method test",
+        method = "reset",
+        args = {}
+    )
+    @AndroidOnly("Tableresult is not cleared when resetting statement: "+
+            "Either complete spec or change implementation accordingly.")
+    public void testReset() throws Exception {
+        db.exec("create table TEST (res integer not null)", null);
+        
+        st = db.prepare("insert into TEST values (:one);");
+        st.bind(1, 1);
+        st.step();
+        
+        // verify that parameter is still bound
+        st.reset();
+        assertEquals(1,st.bind_parameter_count());
+        st.step();
+        
+        TableResult count = db.get_table("select count(*) from TEST where res=1", null);
+        
+        String[] row0 = (String[]) count.rows.elementAt(0);
+        assertEquals(2, Integer.parseInt(row0[0]));
+        
+        //Verify that rest (tableResult) is cleared
+        st = db.prepare("select * from TEST;");
+        st.step();
+        assertEquals(1, st.column_count());
+        st.reset();
+        assertEquals(0,st.column_count());
+    }
+    
+    /**
+     * @tests {@link Stmt#clear_bindings()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "clear_bindings",
+        args = {}
+    )
+    public void testClear_bindings() {
+        try {
+            st.clear_bindings();
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#bind(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind",
+        args = {int.class, int.class}
+    )
+    public void testBindIntInt() {
+        try {
+            int input = 0;
+            int maxVal = Integer.MAX_VALUE;
+            int minVal = Integer.MIN_VALUE;
+           
+            db.exec("create table TEST (res integer)", null);
+            st = db.prepare("insert into TEST values (:one);");
+            st.bind(1, input);
+            st.step();
+            
+            st.reset();
+            st.bind(1,maxVal);
+            st.step();
+            
+            st.reset();
+            st.bind(1,minVal);
+            st.step();
+            
+            TableResult r = db.get_table("select * from TEST");          
+            
+            String[] row0 = (String[]) r.rows.elementAt(0);
+            assertEquals(input,Integer.parseInt(row0[0]));
+            
+            String[] row1 = (String[]) r.rows.elementAt(1);
+            assertEquals(maxVal,Integer.parseInt(row1[0]));
+            
+            String[] row2 = (String[]) r.rows.elementAt(2);
+            assertEquals(minVal,Integer.parseInt(row2[0]));
+
+        } catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind(1,Integer.MIN_VALUE);
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#bind(int, long)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind",
+        args = {int.class, long.class}
+    )
+    public void testBindIntLong() {
+        try {
+            long input = 0;
+            long maxVal = Long.MAX_VALUE;
+            long minVal = Long.MIN_VALUE;
+           
+            db.exec("create table TEST (res long)", null);
+            st = db.prepare("insert into TEST values (:one);");
+            st.bind(1, input);
+            st.step();
+            
+            st.reset();
+            st.bind(1,maxVal);
+            st.step();
+            
+            st.reset();
+            st.bind(1,minVal);
+            st.step();
+          
+            TableResult r = db.get_table("select * from TEST");
+            
+            String[] row0 = (String[]) r.rows.elementAt(0);
+            assertEquals(input,Long.parseLong(row0[0]));
+            
+            String[] row1 = (String[]) r.rows.elementAt(1);
+            assertEquals(maxVal,Long.parseLong(row1[0]));
+            
+            String[] row2 = (String[]) r.rows.elementAt(2);
+            assertEquals(minVal,Long.parseLong(row2[0]));
+
+        } catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind(1,Long.MIN_VALUE);
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#bind(int, double)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind",
+        args = {int.class, double.class}
+    )
+    public void testBindIntDouble() {
+        try {
+            double input = 0.0;
+            double maxVal = Double.MAX_VALUE;
+            double minVal = Double.MIN_VALUE;
+            double negInf = Double.NEGATIVE_INFINITY;
+            double posInf = Double.POSITIVE_INFINITY;
+            double nan = Double.NaN;
+
+            db.exec("create table TEST (res double)", null);
+            st = db.prepare("insert into TEST values (:one);");
+            st.bind(1, input);
+            st.step();
+
+            st.reset();
+            st.bind(1, maxVal);
+            st.step();
+
+            st.reset();
+            st.bind(1, minVal);
+            st.step();
+
+            st.reset();
+            st.bind(1, negInf);
+            st.step();
+
+            st.reset();
+            st.bind(1, posInf);
+            st.step();
+
+            st.reset();
+            st.bind(1, nan);
+            st.step();
+
+
+            TableResult r = db.get_table("select * from TEST");
+
+            String[] row0 = (String[]) r.rows.elementAt(0);
+            assertTrue(Double.compare(input, Double.parseDouble(row0[0])) == 0);
+
+            String[] row1 = (String[]) r.rows.elementAt(1);
+            assertFalse(Double.compare(maxVal, Double.parseDouble(row1[0])) == 0);
+            assertTrue(Double.compare(maxVal, Double.parseDouble(row1[0])) < 0);
+            assertTrue(Double.isInfinite(Double.parseDouble(row1[0])));
+
+            String[] row2 = (String[]) r.rows.elementAt(2);
+            assertTrue(Double.compare(minVal, Double.parseDouble(row2[0])) == 0);
+
+            String[] row3 = (String[]) r.rows.elementAt(3);
+            assertEquals("Double.NEGATIVE_INFINITY SQLite representation",
+                    "-Inf", row3[0]);
+
+            String[] row4 = (String[]) r.rows.elementAt(4);
+            assertEquals("Double.POSITIVE_INFINITY SQLite representation",
+                    "Inf", row4[0]);
+
+            String[] row5 = (String[]) r.rows.elementAt(4);
+            assertEquals("Double.Nan SQLite representation", "Inf", row5[0]);
+
+        } catch (Exception e) {
+            fail("Error in test setup: " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind(1,0.0);
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#bind(int, byte[])}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "bind",
+        args = {int.class, byte[].class}
+    )
+    public void testBindIntByteArray() {
+        
+        String name = "Hello World";
+        
+        try {
+            byte[] b = new byte[name.getBytes().length];
+            b = name.getBytes();
+            String stringInHex = "";
+            
+            db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
+            st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
+                    + " values (:one, :two);");
+            st.bind(1, 2);
+            st.bind(2, b);
+            st.step();
+            
+            //compare what was stored with input based on Hex representation
+            // since type of column is CHAR
+            TableResult r = db.get_table("select * from "
+                    + DatabaseCreator.PARENT_TABLE);          
+            String[] row = (String[]) r.rows.elementAt(0);
+            
+            for (byte aByte : b) {
+                stringInHex += Integer.toHexString(aByte);
+            }
+            stringInHex = "X'" + stringInHex + "'";
+            assertTrue(stringInHex.equalsIgnoreCase(row[1]));
+            
+        } catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind(1,name.getBytes());
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#bind(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testBindIntString() {
+        String name = "Hello World";
+        
+        try {
+           
+            db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null);
+            st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE
+                    + " values (:one, :two);");
+            st.bind(1, 2);
+            st.bind(2, name);
+            st.step();
+            
+            TableResult r = db.get_table("select * from "
+                    + DatabaseCreator.PARENT_TABLE);          
+            String[] row = (String[]) r.rows.elementAt(0);
+            assertEquals(name,row[1]);
+
+        } catch (Exception e) {
+            fail("Error in test setup: "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind(1,name);
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#bind(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind",
+        args = {int.class}
+    )
+    public void testBindInt() {
+        
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            st.bind(4);
+            st.bind(1, 4);
+            st.bind(2, 10);
+            st.bind(3, 30);
+            st.step();
+            fail("Test failes");
+        } catch (Exception e) {
+            // What happens if null is bound to non existing variable position
+            assertEquals("parameter position out of bounds" , e.getMessage());
+        }
+        
+        // functional tests
+        
+        try {
+            st.reset();
+            st.bind(1);
+            st.bind(2, 10);
+            st.bind(3, 30);
+            st.step();
+            fail("Test failes");
+        } catch (Exception e) {
+            // What happens if null is bound to NON NULL field
+            assertEquals("SQL logic error or missing database", e.getMessage());
+        }
+
+        try {
+            st.reset();
+            st.bind(1, 3);
+            st.bind(2);
+            st.bind(3, 30);
+            st.step();
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+        }
+
+    }
+    
+    /**
+     * @tests {@link Stmt#bind_zeroblob(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "bind_zeroblob",
+        args = {int.class, int.class}
+    )
+    public void testBind_zeroblob() {
+        try {
+            st.bind_zeroblob(1, 128);
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#bind_parameter_count()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind_parameter_count",
+        args = {}
+    )
+    public void testBind_parameter_count() {
+        try {
+            st.bind_parameter_count();
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+        
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertEquals(3, st.bind_parameter_count());
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (?, ?, ?)");
+            assertEquals(3, st.bind_parameter_count());
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
+            assertEquals(0, st.bind_parameter_count());
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st.close();
+            st.bind_parameter_count();
+            fail("Exception expected");
+        } catch (Exception e) {
+            //ok
+        }
+        
+    }
+
+    /**
+     * @tests {@link Stmt#bind_parameter_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind_parameter_name",
+        args = {int.class}
+    )
+    public void testBind_parameter_name() {
+        try {
+            st.bind_parameter_name(1);
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+        
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertEquals(":one", st.bind_parameter_name(1));
+            assertEquals(":two", st.bind_parameter_name(2));
+            assertEquals(":three", st.bind_parameter_name(3));
+            String name = st.bind_parameter_name(4);
+        } catch (Exception e) {
+            assertEquals("parameter position out of bounds",e.getMessage());
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#bind_parameter_index(String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "bind_parameter_index",
+        args = {java.lang.String.class}
+    )
+    public void testBind_parameter_index() {
+
+        try {
+            st.bind_parameter_index("");
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals("stmt already closed", e.getMessage());
+        }
+
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertEquals(3, st.bind_parameter_index(":three"));
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            assertEquals(0, st.bind_parameter_index(":t"));
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (?, ?, ?)");
+            assertEquals(0, st.bind_parameter_index("?"));
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        }
+
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_int(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column_int",
+        args = {int.class}
+    )
+    public void testColumn_int() throws Exception {
+        db.exec(createAllTypes, null);
+        db.exec(insertAllTypes, null);
+        
+        int columnObjectCastFromLong;
+        Object columnObject  = null;
+        int intColumn = 0;
+        String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select 'speed' value
+        columnObject = st.column(1);
+        intColumn = st.column_int(1);
+        assertNotNull(intColumn);
+        
+        assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
+        int stSpeed = Integer.parseInt(columnObject.toString());
+        assertNotNull(stSpeed);
+        assertEquals( intColumn, stSpeed);
+        assertEquals(10,stSpeed);
+        
+        selectStmt = "select TextVal from "+allTypesTable;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select double value
+        try {
+            st.column_int(0);
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @tests {@link Stmt#column_long(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column_long",
+        args = {int.class}
+    )
+    public void testColumn_long() {
+        Object columnObject  = null;
+        int columnObjectCastFromLong;
+        long longColumn = 0;
+        try {
+            String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
+            st = db.prepare(selectStmt);
+            st.step();
+            columnObject = st.column(1);
+            longColumn = st.column_long(1);
+            assertNotNull(longColumn);
+            // column declared as integer
+            assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
+            int stSpeed = Integer.parseInt(columnObject.toString());
+            assertNotNull(stSpeed);
+            assertEquals( longColumn, stSpeed);
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        } 
+        
+        try {
+            st.column_long(4);
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals( "column out of bounds" , e.getMessage());
+        }
+        
+        try {
+            st.column_long(-1);
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals( "column out of bounds" , e.getMessage());
+        }
+    }
+    
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_double(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column_double",
+        args = {int.class}
+    )
+    public void testColumn_double() throws Exception {
+        db.exec(createAllTypes, null);
+        db.exec(insertAllTypes, null);
+       
+        Object columnObject  = null;
+        double doubleColumn = 0;
+        double actualVal = 23.2;
+        String selectStmt = "select DoubleVal from "+allTypesTable;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select double value
+        doubleColumn = st.column_double(0);
+        assertNotNull(doubleColumn);
+        
+        assertTrue("DOUBLE".equalsIgnoreCase(st.column_decltype(0)));
+        assertNotNull(doubleColumn);
+        assertEquals( actualVal, doubleColumn);
+        
+        // Exception test
+        selectStmt = "select dateVal from "+allTypesTable;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select double value
+        try {
+        st.column_double(0);
+        } catch (Exception e) {
+            //ok
+        }
+        
+        
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_bytes(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_bytes",
+        args = {int.class}
+    )
+    public void testColumn_bytes() throws Exception {
+        
+        db.exec("create table B(id integer primary key, val blob)",null);
+        db.exec("insert into B values(1, zeroblob(128))", null);
+        st = db.prepare("select val from B where id = 1");
+        assertTrue(st.step());
+        try {
+            st.column_bytes(0);
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_string(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column_string",
+        args = {int.class}
+    )
+    public void testColumn_string() throws Exception {
+        db.exec(createAllTypes, null);
+        db.exec(insertAllTypes, null);
+       
+        Object columnObject  = null;
+        String stringColumn = "";
+        String actualVal = "test string";
+        String selectStmt = "select charStr from "+allTypesTable;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select string value
+        stringColumn = st.column_string(0);
+        assertNotNull(stringColumn);
+        
+        assertTrue("CHAR(20)".equalsIgnoreCase(st.column_decltype(0)));
+        assertNotNull(stringColumn);
+        assertEquals( actualVal, stringColumn);
+        
+        // Exception test
+        selectStmt = "select DoubleVal from "+allTypesTable;
+        
+        st = db.prepare(selectStmt);
+        st.step();
+        // select double value
+        try {
+        st.column_string(0);
+        } catch (Exception e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_type(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "method test",
+        method = "column_type",
+        args = {int.class}
+    )
+    @AndroidOnly("For numeric, float and blob wrong type is returned")
+    public void testColumn_type() throws Exception {
+        db.exec(createAllTypes, null);
+        db.exec(insertAllTypes, null);
+        st = db.prepare("select * from " + allTypesTable);
+        st.step();
+
+        // Exception test
+        try {
+            st.column_type(100);
+        } catch (Exception e) {
+            // ok
+        }
+        
+        /*
+        Dictionary
+        
+        public static final int SQLITE_INTEGER = 1;
+        public static final int SQLITE_FLOAT = 2;
+        public static final int SQLITE_BLOB = 4;
+        public static final int SQLITE_NULL = 5;
+        public static final int SQLITE3_TEXT = 3;
+        public static final int SQLITE_NUMERIC = -1;
+        */
+
+        assertEquals(Constants.SQLITE3_TEXT, st.column_type(23)); // ok TEXT
+        assertEquals(Constants.SQLITE3_TEXT, st.column_type(13)); // CHAR(20)
+
+        assertEquals(Constants.SQLITE_FLOAT, st.column_type(8));
+        assertEquals(Constants.SQLITE_FLOAT, st.column_type(9));
+        assertEquals(Constants.SQLITE_FLOAT, st.column_type(10)); // FLOAT
+
+        for (int i = 0; i < 8; i++) {
+            assertEquals("Expected Integer at position " + i,
+                    Constants.SQLITE_INTEGER, st.column_type(i));
+        }
+
+        assertEquals(Constants.SQLITE_NULL, st.column_type(28));
+        assertEquals(Constants.SQLITE_NULL, st.column_type(29));
+
+        // Failing tests
+        assertTrue("NUMERIC".equalsIgnoreCase(st.column_decltype(12)));
+        assertEquals(Constants.SQLITE_NUMERIC, st.column_type(12)); // NUMERIC
+                                                                    // -> got
+                                                                    // INTEGER
+        
+        assertTrue("FLOAT".equalsIgnoreCase(st.column_decltype(11)));
+        assertEquals(Constants.SQLITE_FLOAT, st.column_type(11)); // FLOAT ->
+                                                                  // got INTEGER
+        assertTrue("BLOB".equalsIgnoreCase(st.column_decltype(19)));
+        assertEquals(Constants.SQLITE_BLOB, st.column_type(19)); // Blob got
+                                                                 // INTEGER
+
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_count() )}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column_count",
+        args = {}
+    )
+    @AndroidOnly("Wrong value is returned in case of a prepared statment to "+
+            "which a '*' bound ")
+    public void testColumn_count() throws Exception {
+        
+        String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
+        st = db.prepare(selectStmt);
+        
+        assertEquals(3, st.column_count());
+        
+        st.step();
+        int columnCount = st.column_count();
+        assertNotNull(columnCount);
+        assertEquals( 3, columnCount);
+        
+        // actual prepared statement
+        selectStmt = "select ? from "+DatabaseCreator.SIMPLE_TABLE1;
+        st = db.prepare(selectStmt);
+        
+        assertEquals(3, st.column_count());
+        
+        st.bind(1, "*");
+        st.step();
+        columnCount = st.column_count();
+        assertNotNull(columnCount);
+        assertEquals( 3, columnCount);
+      
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column(int) )}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "method test",
+        method = "column",
+        args = {int.class}
+    )
+    public void testColumn() throws Exception {
+        Object columnObject  = null;
+        int columnObjectCastFromLong;
+        int intColumn = 0;
+        try {
+            String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
+            TableResult res = db.get_table(selectStmt);
+            st = db.prepare(selectStmt);
+            st.step();
+            columnObject = st.column(1);
+            intColumn = st.column_int(1);
+            assertNotNull(intColumn);
+            assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1)));
+            int stSpeed = Integer.parseInt(columnObject.toString());
+            assertNotNull(stSpeed);
+            assertEquals( intColumn, stSpeed);
+        } catch (Exception e) {
+            fail("Error in test setup : " + e.getMessage());
+            e.printStackTrace();
+        } 
+        
+        try {
+            assertNotNull(columnObject);
+            int dummy = ((Integer) columnObject).intValue();
+            fail("Cast to Integer should fail");
+        } catch (ClassCastException e) {
+            assertEquals("java.lang.Long", e.getMessage());
+        }
+        
+        try {
+            st.column(4);
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals( "column out of bounds" , e.getMessage());
+        }
+        
+        try {
+            st.column(-1);
+            fail("Exception expected");
+        } catch (Exception e) {
+            assertEquals( "column out of bounds" , e.getMessage());
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#column_table_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_table_name",
+        args = {int.class}
+    )
+    public void testColumn_table_name() {
+        try {
+            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
+            String name = st.column_table_name(1);
+           fail("Function is now supported.");
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+    }
+
+    /**
+     * @tests {@link Stmt#column_database_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_database_name",
+        args = {int.class}
+    )
+    public void testColumn_database_name() {
+        try {
+            st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1
+                    + " values (:one,:two,:three)");
+            String name = st.column_database_name(1);
+           fail("Function is now supported.");
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+        
+    }
+
+    /**
+     * @throws Exception 
+     * @tests {@link Stmt#column_decltype(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "method test",
+        method = "column_decltype",
+        args = {int.class}
+    )
+    public void testColumn_decltype() throws Exception {
+        db.exec(createAllTypes, null);
+        db.exec(insertAllTypes, null);
+        st = db.prepare("select * from " + allTypesTable);
+        st.step();
+
+        // Exception test
+        try {
+            st.column_decltype(100);
+        } catch (Exception e) {
+            // ok
+        }
+
+        assertTrue(st.column_decltype(0), "BOOLEAN".equalsIgnoreCase(st
+                .column_decltype(0)));
+        assertTrue(st.column_decltype(1), "INT".equalsIgnoreCase(st
+                .column_decltype(1)));
+        assertTrue(st.column_decltype(2), "LONG".equalsIgnoreCase(st
+                .column_decltype(2)));
+        assertTrue(st.column_decltype(3), "BIGINT".equalsIgnoreCase(st
+                .column_decltype(3)));
+        assertTrue(st.column_decltype(4), "TINYINT".equalsIgnoreCase(st
+                .column_decltype(4)));
+        assertTrue(st.column_decltype(5), "SMALLINT".equalsIgnoreCase(st
+                .column_decltype(5)));
+        assertTrue(st.column_decltype(6), "MEDIUMINT".equalsIgnoreCase(st
+                .column_decltype(6)));
+        assertTrue(st.column_decltype(7), "INTEGER".equalsIgnoreCase(st
+                .column_decltype(7)));
+        assertTrue(st.column_decltype(8), "REAL".equalsIgnoreCase(st
+                .column_decltype(8)));
+        assertTrue(st.column_decltype(9), "DOUBLE".equalsIgnoreCase(st
+                .column_decltype(9)));
+        assertTrue(st.column_decltype(10), "FLOAT".equalsIgnoreCase(st
+                .column_decltype(10)));
+        assertTrue(st.column_decltype(11), "DECIMAL".equalsIgnoreCase(st
+                .column_decltype(11)));
+        assertTrue(st.column_decltype(12), "NUMERIC".equalsIgnoreCase(st
+                .column_decltype(12)));
+        assertTrue(st.column_decltype(13), "CHAR(20)".equalsIgnoreCase(st
+                .column_decltype(13)));
+
+        assertTrue(st.column_decltype(19), "BLOB".equalsIgnoreCase(st
+                .column_decltype(19)));
+
+        assertTrue(st.column_decltype(23), "TEXT".equalsIgnoreCase(st
+                .column_decltype(23)));
+        assertTrue(st.column_decltype(28), "URL".equalsIgnoreCase(st
+                .column_decltype(28)));
+        assertTrue(st.column_decltype(29), "URL".equalsIgnoreCase(st
+                .column_decltype(29)));
+    }
+ 
+    /**
+     * @tests {@link Stmt#column_origin_name(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "column_origin_name",
+        args = {int.class}
+    )
+    public void testColumn_origin_name() {
+        try {
+            st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1);
+            String name = st.column_origin_name(1);
+           fail("Function is now supported.");
+        } catch (Exception e) {
+            assertEquals("unsupported", e.getMessage());
+        }
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/AllTests.java b/sql/src/test/java/tests/java/sql/AllTests.java
new file mode 100644
index 0000000..8c1e51a
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/AllTests.java
@@ -0,0 +1,50 @@
+/*
+ * 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.java.sql;
+
+import junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * This is autogenerated source file. Includes tests for package tests.java.sql;
+ */
+
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(AllTests.suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("All tests for package tests.java.sql;");
+        // $JUnit-BEGIN$
+
+        suite.addTest(DatabaseMetaDataTest.suite());
+        suite.addTest(MultiThreadAccessTest.suite());
+        suite.addTest(StressTest.suite());
+        suite.addTest(UpdateFunctionalityTest.suite());
+        suite.addTest(SelectFunctionalityTest.suite());
+        suite.addTest(UpdateFunctionalityTest2.suite());
+        suite.addTest(DeleteFunctionalityTest.suite());
+        suite.addTest(DatabaseMetaDataTest.suite());
+        suite.addTest(DatabaseMetaDataNotSupportedTest.suite());
+        suite.addTest(InsertFunctionalityTest.suite());
+
+        // $JUnit-END$
+        return suite;
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/DatabaseMetaDataNotSupportedTest.java b/sql/src/test/java/tests/java/sql/DatabaseMetaDataNotSupportedTest.java
new file mode 100644
index 0000000..9f262d9
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/DatabaseMetaDataNotSupportedTest.java
@@ -0,0 +1,2066 @@
+/*
+ * Copyright (C) 2008 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashSet;
+
+@TestTargetClass(DatabaseMetaData.class)
+public class DatabaseMetaDataNotSupportedTest extends TestCase {
+    
+    private static String VIEW_NAME = "myView";
+
+    private static String CREATE_VIEW_QUERY = "CREATE VIEW " + VIEW_NAME
+            + " AS SELECT * FROM " + DatabaseCreator.TEST_TABLE1;
+
+    private static String DROP_VIEW_QUERY = "DROP VIEW " + VIEW_NAME;
+
+    protected static Connection conn;
+
+    protected static DatabaseMetaData meta;
+
+    protected static Statement statement;
+
+    protected static Statement statementForward;
+
+    private static int id = 1;
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                DatabaseMetaDataTest.class)) {
+            protected void setUp() {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    meta = conn.getMetaData();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    System.out.println("Error in test setup: "+e.getMessage());
+                }
+            }
+
+            protected void tearDown() {
+                try {
+                    conn = Support_SQL.getConnection();
+                    meta = conn.getMetaData();
+                    statement = conn.createStatement();
+                    deleteTestTables();
+                } catch (SQLException e) {
+                    System.out.println("Error in teardown: "+e.getMessage());
+                } finally {
+                    try {
+                        conn.close();
+                    } catch (SQLException e) {
+                    }
+                }
+            }
+
+            private void createTestTables() {
+                try {
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE3)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE3);
+                        } else if (tableName.equals(VIEW_NAME)) {
+                            statement.execute(DROP_VIEW_QUERY);
+                        }
+                    }
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE3);
+                    statement.execute(DatabaseCreator.CREATE_TABLE1);
+                    statement.execute(CREATE_VIEW_QUERY);
+                    meta = conn.getMetaData();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE3);
+                    statement.execute(DROP_VIEW_QUERY);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                } finally {
+                    try {
+                    if (! conn.isClosed()) {
+                        conn.close();
+                    }
+                    } catch (SQLException e) {
+                        
+                    }
+                }
+            }
+        };
+        return setup;
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#allProceduresAreCallable()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "Granting not supported.",
+        method = "allProceduresAreCallable",
+        args = {}
+    )
+    public void test_allProceduresAreCallable() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests {@link java.sql.DatabaseMetaData#allTablesAreSelectable()}
+     * 
+     * // NOT_FEASIBLE GRANT and REVOKE are not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "test fails. GRANT and REVOKE not supported",
+        method = "allTablesAreSelectable",
+        args = {}
+    )
+    @KnownFailure("Not supported ops applied")
+    public void test_allTablesAreSelectable() throws SQLException {
+        // grant SELECT privileges
+        
+        String query = "GRANT CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE1
+                + " TO " + Support_SQL.sqlUser;
+        statement.execute(query);
+        Connection userConn = Support_SQL.getConnection(Support_SQL.sqlUrl,
+                Support_SQL.sqlUser, Support_SQL.sqlUser);
+        DatabaseMetaData userMeta = userConn.getMetaData();
+        ResultSet userTab = userMeta.getTables(null, null, null, null);
+
+        assertTrue("Tables are not obtained", userTab.next());
+        assertEquals("Incorrect name of obtained table",
+                DatabaseCreator.TEST_TABLE1.toLowerCase(), userTab.getString(
+                        "TABLE_NAME").toLowerCase());
+        assertTrue("Not all of obtained tables are selectable", userMeta
+                .allTablesAreSelectable());
+
+        userTab.close();
+        // revoke SELECT privileges
+        query = "REVOKE SELECT ON " + DatabaseCreator.TEST_TABLE1 + " FROM "
+                + Support_SQL.sqlUser;
+        statement.execute(query);
+
+        userTab = userMeta.getTables(null, null, null, null);
+
+        assertTrue("Tables are not obtained", userTab.next());
+        assertEquals("Incorrect name of obtained table",
+                DatabaseCreator.TEST_TABLE1.toLowerCase(), userTab.getString(
+                        "TABLE_NAME").toLowerCase());
+        assertFalse("No SELECT privileges", userMeta.allTablesAreSelectable());
+
+        userTab.close();
+        // revoke CREATE privileges
+        query = "REVOKE CREATE ON " + DatabaseCreator.TEST_TABLE1 + " FROM "
+                + Support_SQL.sqlUser;
+        statement.execute(query);
+        userConn.close();
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "dataDefinitionCausesTransactionCommit",
+        args = {}
+    )
+    public void test_dataDefinitionCausesTransactionCommit()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#dataDefinitionIgnoredInTransactions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "dataDefinitionIgnoredInTransactions",
+        args = {}
+    )
+    public void test_dataDefinitionIgnoredInTransactions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#deletesAreDetected(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "deletesAreDetected",
+        args = {int.class}
+    )
+    public void test_deletesAreDetectedI() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#doesMaxRowSizeIncludeBlobs()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "doesMaxRowSizeIncludeBlobs",
+        args = {}
+    )
+    public void test_doesMaxRowSizeIncludeBlobs() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getAttributes(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getAttributes",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getAttributesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getCatalogs()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. not supported. Received result wasn't checked.",
+        method = "getCatalogs",
+        args = {}
+    )
+    public void test_getCatalogs() throws SQLException {
+        ResultSet rs = meta.getCatalogs();
+        // NOT_FEASIBLE getCatalog is not supported
+//        while (rs.next()) {
+            //if (rs.getString("TABLE_CAT").equalsIgnoreCase(conn.getCatalog())) {
+            //    rs.close();
+            //    return;
+            //}
+//        }
+        rs.close();
+//        fail("Incorrect a set of catalogs");
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getCatalogSeparator()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getCatalogSeparator",
+        args = {}
+    )
+    public void test_getCatalogSeparator() throws SQLException {
+        assertTrue("Incorrect catalog separator", "".equals(meta
+                .getCatalogSeparator().trim()));
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getCatalogTerm()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getCatalogTerm",
+        args = {}
+    )
+    public void test_getCatalogTerm() throws SQLException {
+        assertTrue("Incorrect catalog term", "".equals(meta
+                .getCatalogSeparator().trim()));
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getExtraNameCharacters()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getExtraNameCharacters",
+        args = {}
+    )
+    public void test_getExtraNameCharacters() throws SQLException {
+        assertNotNull("Incorrect extra name characters", meta
+                .getExtraNameCharacters());
+       
+    }
+    
+    /**
+     * @tests {@link java.sql.DatabaseMetaData #getIndexInfo(java.lang.String,
+     *        java.lang.String, java.lang.String, boolean, boolean)}
+     *        
+     *  NOT_FEASIBLE getCatalog is not supported      
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. not supported. Received result wasn't checked.",
+        method = "getIndexInfo",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, boolean.class, boolean.class}
+    )
+    public void test_getIndexInfoLjava_lang_StringLjava_lang_StringLjava_lang_StringZZ()
+            throws SQLException {
+        boolean unique = false;
+        ResultSet rs = meta.getIndexInfo(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1, unique, true);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 13, col);
+        String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
+                "NON_UNIQUE", "INDEX_QUALIFIER", "INDEX_NAME", "TYPE",
+                "ORDINAL_POSITION", "COLUMN_NAME", "ASC_OR_DESC",
+                "CARDINALITY", "PAGES", "FILTER_CONDITION" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+
+        assertEquals("Incorrect table catalog", conn.getCatalog(), rs
+                .getString("TABLE_CAT"));
+        assertEquals("Incorrect table schema", null, rs
+                .getString("TABLE_SCHEM"));
+        assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
+                .getString("TABLE_NAME"));
+        assertEquals("Incorrect state of uniquess", unique, rs
+                .getBoolean("NON_UNIQUE"));
+        assertEquals("Incorrect index catalog", "", rs
+                .getString("INDEX_QUALIFIER"));
+        assertEquals("Incorrect index name", "primary", rs.getString(
+                "INDEX_NAME").toLowerCase());
+        assertEquals("Incorrect index type", DatabaseMetaData.tableIndexOther,
+                rs.getShort("TYPE"));
+        assertEquals("Incorrect column sequence number within index", 1, rs
+                .getShort("ORDINAL_POSITION"));
+        assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME"));
+        assertEquals("Incorrect column sort sequence", "a", rs.getString(
+                "ASC_OR_DESC").toLowerCase());
+        assertEquals("Incorrect cardinality", 1, rs.getInt("CARDINALITY"));
+        assertEquals("Incorrect value of pages", 0, rs.getInt("PAGES"));
+        assertEquals("Incorrect filter condition", null, rs
+                .getString("FILTER_CONDITION"));
+        rs.close();
+    }
+    
+    /**
+     * @tests {@link java.sql.DatabaseMetaData #getColumnPrivileges(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)}
+     *        
+     *  NOT_FEASIBLE GRANT is not supported      
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. not supported. Received result wasn't checked.",
+        method = "getColumnPrivileges",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+     public void test_getColumnPrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        ResultSet rs = meta.getColumnPrivileges(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1, "id");
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertFalse("Rows are obtained", rs.next());
+        rs.close();
+
+        String query = "GRANT REFERENCES(id) ON " + DatabaseCreator.TEST_TABLE1
+                + " TO " + Support_SQL.sqlLogin;
+        statement.execute(query);
+
+        rs = meta.getColumnPrivileges(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1, "id");
+        rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 8, col);
+        String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
+                "COLUMN_NAME", "GRANTOR", "GRANTEE", "PRIVILEGE",
+                "IS_GRANTABLE" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+        assertEquals("Incorrect table catalogue", conn.getCatalog(), rs
+                .getString("TABLE_CAT").toLowerCase());
+        assertEquals("Incorrect table schema", null, rs
+                .getString("TABLE_SCHEM"));
+        assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
+                .getString("TABLE_NAME").toLowerCase());
+        assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME")
+                .toLowerCase());
+        assertEquals("Incorrect grantor", Support_SQL.sqlLogin + "@"
+                + Support_SQL.sqlHost, rs.getString("GRANTOR").toLowerCase());
+        assertTrue("Incorrect grantee",
+                rs.getString("GRANTEE").indexOf("root") != -1);
+        assertEquals("Incorrect privilege", "references", rs.getString(
+                "PRIVILEGE").toLowerCase());
+
+        query = "REVOKE REFERENCES(id) ON " + DatabaseCreator.TEST_TABLE1
+                + " FROM " + Support_SQL.sqlLogin;
+        statement.execute(query);
+        rs.close();
+    }
+
+    
+    /**
+     * @tests {@link java.sql.DatabaseMetaData #getExportedKeys(java.lang.String,
+     *        java.lang.String, java.lang.String)}
+     *        
+     * NOT_FEASIBLE foreign keys are not supported       
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. not supported. Received result wasn't checked.",
+        method = "getExportedKeys",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+     public void test_getExportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        ResultSet rs = meta.getExportedKeys(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE3);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 14, col);
+        String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
+                "PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
+                "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
+                "UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
+                "DEFERRABILITY" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+
+        assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
+                rs.getString("PKTABLE_CAT"));
+        assertEquals("Incorrect primary key table schema", null, rs
+                .getString("PKTABLE_SCHEM"));
+        assertEquals("Incorrect primary key table name",
+                DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
+        assertEquals("Incorrect primary key column name", "fk", rs
+                .getString("PKCOLUMN_NAME"));
+        assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
+                rs.getString("FKTABLE_CAT"));
+        assertEquals("Incorrect foreign key table schema", null, rs
+                .getString("FKTABLE_SCHEM"));
+        assertEquals("Incorrect foreign key table name",
+                DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
+        assertEquals("Incorrect foreign key column name", "fkey", rs
+                .getString("FKCOLUMN_NAME"));
+        assertEquals("Incorrect sequence number within foreign key", 1, rs
+                .getShort("KEY_SEQ"));
+        assertEquals("Incorrect update rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("UPDATE_RULE"));
+        assertEquals("Incorrect delete rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("DELETE_RULE"));
+        assertNotNull("Incorrect foreign key name", rs.getString("FK_NAME"));
+        assertEquals("Incorrect primary key name", null, rs
+                .getString("PK_NAME"));
+        assertEquals("Incorrect deferrability",
+                DatabaseMetaData.importedKeyNotDeferrable, rs
+                        .getShort("DEFERRABILITY"));
+        rs.close();
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getProcedureColumns(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getProcedureColumns",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getProcedureColumnsLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getProcedures(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getProcedures",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getProceduresLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getProcedureTerm()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getProcedureTerm",
+        args = {}
+    )
+    public void test_getProcedureTerm() throws SQLException {
+        assertTrue("Incorrect procedure term", "".equals(meta
+                .getProcedureTerm().trim()));
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getProcedureTerm();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getSchemaTerm()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getSchemaTerm",
+        args = {}
+    )
+    public void test_getSchemaTerm() throws SQLException {
+        String term = meta.getSchemaTerm();
+        assertNotNull("Incorrect schema term", term );
+        
+        assertTrue("".equals(term));
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSchemaTerm();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+     
+    /**
+     * @tests java.sql.DatabaseMetaData #getSuperTables(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getSuperTables",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getSuperTablesLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getSuperTypes(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getSuperTypes",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getSuperTypesLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getTablePrivileges(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     *        
+     *  NOT_FEASIBLE GRANT is not supported      
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. not supported. Received result wasn't checked.",
+        method = "getTablePrivileges",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    public void test_getTablePrivilegesLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        // case 1. Get privileges when no privilegies exist for one table
+        ResultSet privileges = meta.getTablePrivileges(conn.getCatalog(), "%",
+                DatabaseCreator.TEST_TABLE3);
+        assertFalse("Some privilegies exist", privileges.next());
+        privileges.close();
+
+        // case 2. Get privileges when no privilegies exist for all tables
+        privileges = meta.getTablePrivileges(null, null, null);
+        assertFalse("Some privilegies exist", privileges.next());
+        privileges.close();
+
+        // case 3. grant CREATE and SELECT privileges ang get them
+        HashSet<String> expectedPrivs = new HashSet<String>();
+        expectedPrivs.add("CREATE");
+        expectedPrivs.add("SELECT");
+
+        String query = "GRANT CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE3
+                + " TO " + Support_SQL.sqlUser;
+        statement.execute(query);
+
+        privileges = meta.getTablePrivileges(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE3);
+
+        while (privileges.next()) {
+            assertEquals("Wrong catalog name", Support_SQL.sqlCatalog,
+                    privileges.getString("TABLE_CAT"));
+            assertNull("Wrong schema", privileges.getString("TABLE_SCHEM"));
+            assertEquals("Wrong table name", DatabaseCreator.TEST_TABLE3,
+                    privileges.getString("TABLE_NAME"));
+            assertTrue("Wrong privilege " + privileges.getString("PRIVILEGE"),
+                    expectedPrivs.remove(privileges.getString("PRIVILEGE")));
+            assertEquals("Wrong grantor", Support_SQL.sqlLogin + "@"
+                    + Support_SQL.sqlHost, privileges.getString("GRANTOR"));
+            assertEquals("Wrong grantee", Support_SQL.sqlUser + "@%",
+                    privileges.getString("GRANTEE"));
+            assertNull("Wrong value of IS_GRANTABLE", privileges
+                    .getString("IS_GRANTABLE"));
+        }
+        privileges.close();
+        assertTrue("Wrong privileges were returned", expectedPrivs.isEmpty());
+
+        query = "REVOKE CREATE, SELECT ON " + DatabaseCreator.TEST_TABLE3
+                + " FROM " + Support_SQL.sqlUser;
+        statement.execute(query);
+
+        // case 4. grant all privileges ang get them
+        String[] privs = new String[] { "ALTER", "CREATE", "CREATE VIEW",
+                "DELETE", "DROP", "INDEX", "INSERT", "REFERENCES", "SELECT",
+                "SHOW VIEW", "UPDATE" };
+        expectedPrivs = new HashSet<String>();
+        for (int i = 0; i < privs.length; i++) {
+            expectedPrivs.add(privs[i]);
+        }
+        query = "GRANT ALL ON " + DatabaseCreator.TEST_TABLE3 + " TO "
+                + Support_SQL.sqlUser;
+        statement.execute(query);
+
+        privileges = meta.getTablePrivileges(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE3);
+
+        while (privileges.next()) {
+            assertEquals("Wrong catalog name", Support_SQL.sqlCatalog,
+                    privileges.getString("TABLE_CAT"));
+            assertNull("Wrong schema", privileges.getString("TABLE_SCHEM"));
+            assertEquals("Wrong table name", DatabaseCreator.TEST_TABLE3,
+                    privileges.getString("TABLE_NAME"));
+            assertTrue("Wrong privilege " + privileges.getString("PRIVILEGE"),
+                    expectedPrivs.remove(privileges.getString("PRIVILEGE")));
+            assertEquals("Wrong grantor", Support_SQL.sqlLogin + "@"
+                    + Support_SQL.sqlHost, privileges.getString("GRANTOR"));
+            assertEquals("Wrong grantee", Support_SQL.sqlUser + "@%",
+                    privileges.getString("GRANTEE"));
+            assertNull("Wrong value of IS_GRANTABLE", privileges
+                    .getString("IS_GRANTABLE"));
+        }
+        privileges.close();
+        assertTrue("Wrong privileges were returned", expectedPrivs.isEmpty());
+
+        query = "REVOKE ALL ON " + DatabaseCreator.TEST_TABLE3 + " FROM "
+                + Support_SQL.sqlUser;
+        statement.execute(query);
+
+        // case 5. check no privelegies after revoke
+        privileges = meta.getTablePrivileges(conn.getCatalog(), "%",
+                DatabaseCreator.TEST_TABLE3);
+        assertFalse("Some privilegies exist", privileges.next());
+        privileges.close();
+
+        privileges = meta.getTablePrivileges(null, null, null);
+        assertFalse("Some privilegies exist", privileges.next());
+        privileges.close();
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getUDTs(java.lang.String,
+     *        java.lang.String, java.lang.String, int[])
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getUDTs",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int[].class}
+    )
+    public void test_getUDTsLjava_lang_StringLjava_lang_StringLjava_lang_String$I()
+            throws SQLException {
+        // NOT_FEASIBLE: JDBC does not implement this functionality
+    }
+   
+    /**
+     * @tests java.sql.DatabaseMetaData #getVersionColumns(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     *  
+     *  NOT_FEASIBLE trigger is not supported       
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. Received result wasn't checked.Triggers not supported",
+        method = "getVersionColumns",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Not supported ops applied")
+    public void test_getVersionColumnsLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        DatabaseMetaDataTest.insertNewRecord();
+
+        String triggerName = "updateTrigger";
+        String triggerQuery = "CREATE TRIGGER " + triggerName
+                + " AFTER UPDATE ON " + DatabaseCreator.TEST_TABLE1
+                + " FOR EACH ROW BEGIN INSERT INTO "
+                + DatabaseCreator.TEST_TABLE3 + " SET fk = 10; END;";
+        statementForward.execute(triggerQuery);
+
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field1='fffff' WHERE id=1";
+        statementForward.execute(updateQuery);
+
+        ResultSet rs = meta.getVersionColumns(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1);
+        assertTrue("Result set is empty", rs.next());
+        rs.close();
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#isCatalogAtStart()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isCatalogAtStart",
+        args = {}
+    )
+    public void test_isCatalogAtStart() throws SQLException {
+        assertFalse(
+                "catalog doesn't appear at the start of a fully qualified table name",
+                meta.isCatalogAtStart());
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.isCatalogAtStart();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#locatorsUpdateCopy()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "locatorsUpdateCopy",
+        args = {}
+    )
+    public void test_locatorsUpdateCopy() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#nullPlusNonNullIsNull()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "nullPlusNonNullIsNull",
+        args = {}
+    )
+    public void test_nullPlusNonNullIsNull() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#nullsAreSortedAtEnd()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "nullsAreSortedAtEnd",
+        args = {}
+    )
+    public void test_nullsAreSortedAtEnd() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#nullsAreSortedAtStart()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "nullsAreSortedAtStart",
+        args = {}
+    )
+    public void test_nullsAreSortedAtStart() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#nullsAreSortedHigh()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "nullsAreSortedHigh",
+        args = {}
+    )
+    public void test_nullsAreSortedHigh() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#nullsAreSortedLow()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "nullsAreSortedLow",
+        args = {}
+    )
+    public void test_nullsAreSortedLow() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#ownDeletesAreVisible(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not Fully Supported.",
+        method = "ownDeletesAreVisible",
+        args = {int.class}
+    )
+    public void test_ownDeletesAreVisibleI() throws SQLException {
+        // NOT_FEASIBLE not supported
+//        assertFalse(
+//                "result set's own deletes are visible for TYPE_FORWARD_ONLY type",
+//                meta.ownDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+//        assertFalse(
+//                "result set's own deletes are visible for TYPE_SCROLL_INSENSITIVE type",
+//               meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+//        assertFalse(
+//                "result set's own deletes are visible for TYPE_SCROLL_SENSITIVE type",
+//                meta.ownDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        assertFalse("result set's own deletes are visible for unknown type",
+                meta.ownDeletesAreVisible(100));
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#ownInsertsAreVisible(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported.",
+        method = "ownInsertsAreVisible",
+        args = {int.class}
+    )
+    public void test_ownInsertsAreVisibleI() throws SQLException {
+//        assertFalse(
+//                "result set's own inserts are visible for TYPE_FORWARD_ONLY type",
+//                meta.ownInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+//        assertFalse(
+//                "result set's own inserts are visible for TYPE_SCROLL_INSENSITIVE type",
+//                meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+//        assertFalse(
+//                "result set's own inserts are visible for TYPE_SCROLL_SENSITIVE type",
+//                meta.ownInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        assertFalse("result set's own inserts are visible for unknown type",
+                meta.ownInsertsAreVisible(100));
+    }
+
+    /**
+     * @tests {@link java.sql.DatabaseMetaData#ownUpdatesAreVisible(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. Verification with invalid parameters missed.",
+        method = "ownUpdatesAreVisible",
+        args = {int.class}
+    )
+    @KnownFailure("Not supported ops applied")
+    public void test_ownUpdatesAreVisibleI() throws SQLException {
+        // NOT_FEASIBLE not supported
+        assertFalse(
+                "result set's own updates are visible for TYPE_FORWARD_ONLY type",
+                meta.ownUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "result set's own updates are visible for TYPE_SCROLL_INSENSITIVE type",
+                meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "result set's own updates are visible for TYPE_SCROLL_SENSITIVE type",
+                meta.ownUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        assertFalse("result set's own updates are visible for unknown type",
+                meta.ownUpdatesAreVisible(100));
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#storesLowerCaseIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "storesLowerCaseIdentifiers",
+        args = {}
+    )
+    public void test_storesLowerCaseIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#storesLowerCaseQuotedIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "storesLowerCaseQuotedIdentifiers",
+        args = {}
+    )
+    public void test_storesLowerCaseQuotedIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#storesUpperCaseIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "storesUpperCaseIdentifiers",
+        args = {}
+    )
+    public void test_storesUpperCaseIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#storesUpperCaseQuotedIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "storesUpperCaseQuotedIdentifiers",
+        args = {}
+    )
+    public void test_storesUpperCaseQuotedIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsANSI92EntryLevelSQL()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsANSI92EntryLevelSQL",
+        args = {}
+    )
+    public void test_supportsANSI92EntryLevelSQL() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsANSI92FullSQL()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsANSI92FullSQL",
+        args = {}
+    )
+    public void test_supportsANSI92FullSQL() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsANSI92IntermediateSQL()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsANSI92IntermediateSQL",
+        args = {}
+    )
+    public void test_supportsANSI92IntermediateSQL() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsAlterTableWithAddColumn()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsAlterTableWithAddColumn",
+        args = {}
+    )
+    public void test_supportsAlterTableWithAddColumn() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsAlterTableWithDropColumn()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsAlterTableWithDropColumn",
+        args = {}
+    )
+    public void test_supportsAlterTableWithDropColumn() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsBatchUpdates()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsBatchUpdates",
+        args = {}
+    )
+    public void test_supportsBatchUpdates() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCatalogsInDataManipulation()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCatalogsInDataManipulation",
+        args = {}
+    )
+    public void test_supportsCatalogsInDataManipulation() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCatalogsInIndexDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCatalogsInIndexDefinitions",
+        args = {}
+    )
+    public void test_supportsCatalogsInIndexDefinitions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCatalogsInPrivilegeDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCatalogsInPrivilegeDefinitions",
+        args = {}
+    )
+    public void test_supportsCatalogsInPrivilegeDefinitions()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCatalogsInProcedureCalls()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCatalogsInProcedureCalls",
+        args = {}
+    )
+    public void test_supportsCatalogsInProcedureCalls() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCatalogsInTableDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCatalogsInTableDefinitions",
+        args = {}
+    )
+    public void test_supportsCatalogsInTableDefinitions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsConvert()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsConvert",
+        args = {}
+    )
+    public void test_supportsConvert() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsConvert(int, int)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsConvert",
+        args = {int.class, int.class}
+    )
+    public void test_supportsConvertII() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCoreSQLGrammar()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCoreSQLGrammar",
+        args = {}
+    )
+    public void test_supportsCoreSQLGrammar() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsCorrelatedSubqueries()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsCorrelatedSubqueries",
+        args = {}
+    )
+    public void test_supportsCorrelatedSubqueries() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsDataDefinitionAndDataManipulationTransactions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsDataDefinitionAndDataManipulationTransactions",
+        args = {}
+    )
+    public void test_supportsDataDefinitionAndDataManipulationTransactions()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsDataManipulationTransactionsOnly()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsDataManipulationTransactionsOnly",
+        args = {}
+    )
+    public void test_supportsDataManipulationTransactionsOnly()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsDifferentTableCorrelationNames()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsDifferentTableCorrelationNames",
+        args = {}
+    )
+    public void test_supportsDifferentTableCorrelationNames()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsExtendedSQLGrammar()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsExtendedSQLGrammar",
+        args = {}
+    )
+    public void test_supportsExtendedSQLGrammar() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsFullOuterJoins()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsFullOuterJoins",
+        args = {}
+    )
+    public void test_supportsFullOuterJoins() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsGetGeneratedKeys()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsGetGeneratedKeys",
+        args = {}
+    )
+    public void test_supportsGetGeneratedKeys() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsGroupByBeyondSelect()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsGroupByBeyondSelect",
+        args = {}
+    )
+    public void test_supportsGroupByBeyondSelect() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsIntegrityEnhancementFacility()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsIntegrityEnhancementFacility",
+        args = {}
+    )
+    public void test_supportsIntegrityEnhancementFacility() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsLikeEscapeClause()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsLikeEscapeClause",
+        args = {}
+    )
+    public void test_supportsLikeEscapeClause() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsLimitedOuterJoins()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsLimitedOuterJoins",
+        args = {}
+    )
+    public void test_supportsLimitedOuterJoins() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMinimumSQLGrammar()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMinimumSQLGrammar",
+        args = {}
+    )
+    public void test_supportsMinimumSQLGrammar() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMixedCaseIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMixedCaseIdentifiers",
+        args = {}
+    )
+    public void test_supportsMixedCaseIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMixedCaseQuotedIdentifiers()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMixedCaseQuotedIdentifiers",
+        args = {}
+    )
+    public void test_supportsMixedCaseQuotedIdentifiers() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMultipleOpenResults()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMultipleOpenResults",
+        args = {}
+    )
+    public void test_supportsMultipleOpenResults() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMultipleResultSets()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMultipleResultSets",
+        args = {}
+    )
+    public void test_supportsMultipleResultSets() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsMultipleTransactions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsMultipleTransactions",
+        args = {}
+    )
+    public void test_supportsMultipleTransactions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsNamedParameters()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsNamedParameters",
+        args = {}
+    )
+    public void test_supportsNamedParameters() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOpenCursorsAcrossCommit()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsOpenCursorsAcrossCommit",
+        args = {}
+    )
+    public void test_supportsOpenCursorsAcrossCommit() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOpenCursorsAcrossRollback()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsOpenCursorsAcrossRollback",
+        args = {}
+    )
+    public void test_supportsOpenCursorsAcrossRollback() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOpenStatementsAcrossCommit()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsOpenStatementsAcrossCommit",
+        args = {}
+    )
+    public void test_supportsOpenStatementsAcrossCommit() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOpenStatementsAcrossRollback()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsOpenStatementsAcrossRollback",
+        args = {}
+    )
+    public void test_supportsOpenStatementsAcrossRollback() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOuterJoins()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsOuterJoins",
+        args = {}
+    )
+    public void test_supportsOuterJoins() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsPositionedDelete()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsPositionedDelete",
+        args = {}
+    )
+    public void test_supportsPositionedDelete() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsPositionedUpdate()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsPositionedUpdate",
+        args = {}
+    )
+    public void test_supportsPositionedUpdate() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsResultSetConcurrency(int, int)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsResultSetConcurrency",
+        args = {int.class, int.class}
+    )
+    public void test_supportsResultSetConcurrencyII() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsResultSetHoldability(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsResultSetHoldability",
+        args = {int.class}
+    )
+    public void test_supportsResultSetHoldabilityI() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsResultSetType(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported. Verification with invalid parameters missed.",
+        method = "supportsResultSetType",
+        args = {int.class}
+    )
+    public void test_supportsResultSetTypeI() throws SQLException {
+        // NOT_FEASIBLE not supported
+//        assertFalse("database supports TYPE_FORWARD_ONLY type", meta
+//                .supportsResultSetType(ResultSet.TYPE_FORWARD_ONLY));
+//        assertTrue("database doesn't support TYPE_SCROLL_INSENSITIVE type",
+//                meta.supportsResultSetType(ResultSet.TYPE_SCROLL_INSENSITIVE));
+//        assertFalse("database supports TYPE_SCROLL_SENSITIVE type", meta
+//                .supportsResultSetType(ResultSet.TYPE_SCROLL_SENSITIVE));
+        assertFalse("database supports unknown type", meta
+                .supportsResultSetType(100));
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSavepoints()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSavepoints",
+        args = {}
+    )
+    public void test_supportsSavepoints() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSchemasInDataManipulation()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSchemasInDataManipulation",
+        args = {}
+    )
+    public void test_supportsSchemasInDataManipulation() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSchemasInIndexDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSchemasInIndexDefinitions",
+        args = {}
+    )
+    public void test_supportsSchemasInIndexDefinitions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSchemasInPrivilegeDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSchemasInPrivilegeDefinitions",
+        args = {}
+    )
+    public void test_supportsSchemasInPrivilegeDefinitions()
+            throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSchemasInProcedureCalls()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSchemasInProcedureCalls",
+        args = {}
+    )
+    public void test_supportsSchemasInProcedureCalls() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSchemasInTableDefinitions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSchemasInTableDefinitions",
+        args = {}
+    )
+    public void test_supportsSchemasInTableDefinitions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsStatementPooling()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsStatementPooling",
+        args = {}
+    )
+    public void test_supportsStatementPooling() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsStoredProcedures()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsStoredProcedures",
+        args = {}
+    )
+    public void test_supportsStoredProcedures() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSubqueriesInComparisons()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSubqueriesInComparisons",
+        args = {}
+    )
+    public void test_supportsSubqueriesInComparisons() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSubqueriesInIns()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSubqueriesInIns",
+        args = {}
+    )
+    public void test_supportsSubqueriesInIns() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSubqueriesInQuantifieds()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsSubqueriesInQuantifieds",
+        args = {}
+    )
+    public void test_supportsSubqueriesInQuantifieds() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsTransactions()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsTransactions",
+        args = {}
+    )
+    public void test_supportsTransactions() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsUnion()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsUnion",
+        args = {}
+    )
+    public void test_supportsUnion() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsUnionAll()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "supportsUnionAll",
+        args = {}
+    )
+    public void test_supportsUnionAll() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#usesLocalFilePerTable()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "usesLocalFilePerTable",
+        args = {}
+    )
+    public void test_usesLocalFilePerTable() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#usesLocalFiles()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "usesLocalFiles",
+        args = {}
+    )
+    public void test_usesLocalFiles() throws SQLException {
+        // NOT_FEASIBLE: SQLITE does not implement this functionality
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxBinaryLiteralLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxBinaryLiteralLength",
+        args = {}
+    )
+    public void test_getMaxBinaryLiteralLength() throws SQLException {
+        assertTrue("Incorrect binary literal length", meta
+                .getMaxBinaryLiteralLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxCatalogNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxCatalogNameLength",
+        args = {}
+    )
+    public void test_getMaxCatalogNameLength() throws SQLException {
+        assertTrue("Incorrect name length", meta.getMaxCatalogNameLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxCharLiteralLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxCharLiteralLength",
+        args = {}
+    )
+    public void test_getMaxCharLiteralLength() throws SQLException {
+        assertTrue("Incorrect char literal length", meta
+                .getMaxCharLiteralLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnNameLength",
+        args = {}
+    )
+    public void test_getMaxColumnNameLength() throws SQLException {
+        assertTrue("Incorrect column name length", meta
+                .getMaxColumnNameLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnsInGroupBy()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnsInGroupBy",
+        args = {}
+    )
+    public void test_getMaxColumnsInGroupBy() throws SQLException {
+        assertTrue("Incorrect number of columns",
+                meta.getMaxColumnsInGroupBy() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnsInIndex()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnsInIndex",
+        args = {}
+    )
+    public void test_getMaxColumnsInIndex() throws SQLException {
+        assertTrue("Incorrect number of columns",
+                meta.getMaxColumnsInIndex() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnsInOrderBy()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnsInOrderBy",
+        args = {}
+    )
+    public void test_getMaxColumnsInOrderBy() throws SQLException {
+        assertTrue("Incorrect number of columns",
+                meta.getMaxColumnsInOrderBy() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnsInSelect()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnsInSelect",
+        args = {}
+    )
+    public void test_getMaxColumnsInSelect() throws SQLException {
+        assertTrue("Incorrect number of columns",
+                meta.getMaxColumnsInSelect() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxColumnsInTable()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxColumnsInTable",
+        args = {}
+    )
+    public void test_getMaxColumnsInTable() throws SQLException {
+        assertTrue("Incorrect number of columns",
+                meta.getMaxColumnsInTable() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxConnections()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxConnections",
+        args = {}
+    )
+    public void test_getMaxConnections() throws SQLException {
+        assertTrue("Incorrect number of connections",
+                meta.getMaxConnections() == 0);
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxIndexLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxIndexLength",
+        args = {}
+    )
+    public void test_getMaxIndexLength() throws SQLException {
+        assertTrue("Incorrect length of index", meta.getMaxIndexLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxProcedureNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxProcedureNameLength",
+        args = {}
+    )
+    public void test_getMaxProcedureNameLength() throws SQLException {
+        assertTrue("Incorrect length of procedure name", meta
+                .getMaxProcedureNameLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxRowSize()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxRowSize",
+        args = {}
+    )
+    public void test_getMaxRowSize() throws SQLException {
+        assertTrue("Incorrect size of row", meta.getMaxRowSize() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxSchemaNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxSchemaNameLength",
+        args = {}
+    )
+    public void test_getMaxSchemaNameLength() throws SQLException {
+        assertTrue("Incorrect length of schema name", meta
+                .getMaxSchemaNameLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxStatementLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxStatementLength",
+        args = {}
+    )
+    public void test_getMaxStatementLength() throws SQLException {
+        assertTrue("Incorrect length of statement", meta
+                .getMaxStatementLength() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxStatements()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxStatements",
+        args = {}
+    )
+    public void test_getMaxStatements() throws SQLException {
+        assertTrue("Incorrect number of statements",
+                meta.getMaxStatements() == 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxTableNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxTableNameLength",
+        args = {}
+    )
+    public void test_getMaxTableNameLength() throws SQLException {
+        assertTrue("Now supported", meta
+                .getMaxTableNameLength() == 0);
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getMaxTableNameLength();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxTablesInSelect()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxTablesInSelect",
+        args = {}
+    )
+    public void test_getMaxTablesInSelect() throws SQLException {
+        assertTrue("Tables in select is now supported: change test implementation\"",
+                meta.getMaxTablesInSelect() == 0);
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getMaxTablesInSelect();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxUserNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "usernames not supported",
+        method = "getMaxUserNameLength",
+        args = {}
+    )
+    public void test_getMaxUserNameLength() throws SQLException {
+        assertTrue("Usernames are now supported: change test implementation",
+                meta.getMaxUserNameLength() == 0);
+        
+      //Excpetion checking
+        conn.close();
+         
+         try {
+             meta.getMaxUserNameLength();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+    
+
+}
diff --git a/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java b/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java
new file mode 100755
index 0000000..fe7b227
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java
@@ -0,0 +1,2819 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Random;
+import java.util.StringTokenizer;
+
+@TestTargetClass(DatabaseMetaData.class)
+public class DatabaseMetaDataTest extends TestCase {
+    private static String VIEW_NAME = "myView";
+
+    private static String CREATE_VIEW_QUERY = "CREATE VIEW " + VIEW_NAME
+            + " AS SELECT * FROM " + DatabaseCreator.TEST_TABLE1;
+
+    private static String DROP_VIEW_QUERY = "DROP VIEW " + VIEW_NAME;
+
+    protected static Connection conn;
+
+    protected static DatabaseMetaData meta;
+
+    protected static Statement statement;
+
+    protected static Statement statementForward;
+
+    private static int id = 1;
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                DatabaseMetaDataTest.class)) {
+            protected void setUp() {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    meta = conn.getMetaData();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    System.out.println("Error in test setup: "+e.getMessage());
+                }
+            }
+
+            protected void tearDown() {
+                try {
+                    conn = Support_SQL.getConnection();
+                    meta = conn.getMetaData();
+                    statement = conn.createStatement();
+                    deleteTestTables();
+                } catch (SQLException e) {
+                    System.out.println("Error in teardown: "+e.getMessage());
+                } finally {
+                    try {
+                        conn.close();
+                    } catch (SQLException e) {
+                    }
+                }
+            }
+
+            private void createTestTables() {
+                try {
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE3)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE3);
+                        } else if (tableName.equals(VIEW_NAME)) {
+                            statement.execute(DROP_VIEW_QUERY);
+                        }
+                    }
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE3);
+                    statement.execute(DatabaseCreator.CREATE_TABLE1);
+                    statement.execute(CREATE_VIEW_QUERY);
+                    meta = conn.getMetaData();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE3);
+                    statement.execute(DROP_VIEW_QUERY);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                } finally {
+                    try {
+                    if (! conn.isClosed()) {
+                        conn.close();
+                    }
+                    } catch (SQLException e) {
+                        
+                    }
+                }
+            }
+        };
+        return setup;
+    }
+    
+    public void setUp() {
+        try {
+            super.setUp();
+            try {
+                conn = Support_SQL.getConnection();
+                statement = conn.createStatement();
+                statementForward = conn.createStatement(
+                        ResultSet.TYPE_FORWARD_ONLY,
+                        ResultSet.CONCUR_UPDATABLE);
+                meta = conn.getMetaData();
+                
+                assertFalse(conn.isClosed());
+            } catch (SQLException e) {
+                fail("Unexpected SQLException " + e.toString());
+            }
+            
+        } catch (Exception e) {
+            // TODO Auto-generated catch block
+            e.printStackTrace();
+        }
+        
+    }
+    
+    /**
+     * @tests {@link java.sql.DatabaseMetaData #getBestRowIdentifier(java.lang.String,
+     *        java.lang.String, java.lang.String, int, boolean) }
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not All variants of parameters can be tested: updates on resultSets are not supported.",
+        method = "getBestRowIdentifier",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, int.class, boolean.class}
+    )
+    public void test_getBestRowIdentifierLjava_lang_StringLjava_lang_StringLjava_lang_StringIZ()
+            throws SQLException {
+        ResultSet result = statementForward.executeQuery("SELECT * FROM "
+                + DatabaseCreator.TEST_TABLE1);
+
+        // TODO not supported
+        // try {
+        // result.moveToInsertRow();
+        // result.updateInt("id", 1234567);
+        // result.updateString("field1", "test1");
+        // result.insertRow();
+        // } catch (SQLException e) {
+        // fail("Unexpected SQLException " + e.toString());
+        // }
+
+        result.close();
+
+        ResultSet rs = meta.getBestRowIdentifier(null, null,
+                DatabaseCreator.TEST_TABLE1, DatabaseMetaData.bestRowSession,
+                true);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 8, col);
+        String[] columnNames = {
+                "SCOPE", "COLUMN_NAME", "DATA_TYPE", "TYPE_NAME",
+                "COLUMN_SIZE", "BUFFER_LENGTH", "DECIMAL_DIGITS",
+                "PSEUDO_COLUMN"};
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+        assertEquals("Incorrect scope", DatabaseMetaData.bestRowSession, rs
+                .getShort("SCOPE"));
+        assertEquals("Incorrect column name", "_ROWID_", rs.getString("COLUMN_NAME"));
+        assertEquals("Incorrect data type", java.sql.Types.INTEGER, rs.getInt("DATA_TYPE"));
+        assertEquals("Incorrect type name", "INTEGER", rs.getString("TYPE_NAME"));
+        rs.close();
+        
+     // Exception testing
+        conn.close();
+
+        try {
+            meta.getColumns(null, null,
+            DatabaseCreator.TEST_TABLE1, "%");
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)
+     *           
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Tests Columns and search for arbitrary columns. test fails: Columns Name's not according to spec.",
+        method = "getColumns",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Not supported : pattern with %")
+    public void test_getColumnsArbitrary() throws SQLException {
+        ResultSet setAllNull = null;
+        ResultSet setMixed = null;
+        ResultSet allArbitrary = null;
+        String[] tablesName = {DatabaseCreator.TEST_TABLE1,
+                DatabaseCreator.TEST_TABLE3};
+        Arrays.sort(tablesName);
+        int setSize = 0; 
+        try {
+            allArbitrary = meta.getColumns("%","%","%","%");
+            assertNotNull(allArbitrary);
+            checkColumnsShape(allArbitrary);
+            setSize = crossCheckGetColumnsAndResultSetMetaData(allArbitrary, false);
+            assertEquals(6, setSize);
+            
+            setMixed = meta.getColumns(null, null,"%","%");
+            assertNotNull(setMixed);
+            checkColumnsShape(setMixed);
+            setSize = crossCheckGetColumnsAndResultSetMetaData(setMixed, false);
+            assertEquals(6, setSize);
+            
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        // Exception testing
+        conn.close();
+
+        try {
+            meta.getColumns(null, null,
+                    DatabaseCreator.TEST_TABLE1, "%");
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)
+     *           
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Tests getColumns with no Catalog and Schema. test fails on arguments: '', '', '%', '%'",
+        method = "getColumns",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Not supported ops applied: test fails on arguments: '', '', '%', '%' ")
+    public void test_getColumnsTableWithNoCatalogSchema() throws SQLException{
+
+        try {
+            ResultSet noSchemaTable = meta.getColumns("", "",
+                    DatabaseCreator.TEST_TABLE1, "fkey");
+            assertNotNull(noSchemaTable);
+            noSchemaTable.last();
+            int size = noSchemaTable.getRow();
+            assertEquals(
+                    "Does not support empty string as input parameter or Wildcard %",
+                    1, size);
+
+
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            ResultSet noSchemaTable = meta.getColumns("", "",
+                    DatabaseCreator.TEST_TABLE1, "%");
+            assertNotNull(noSchemaTable);
+            noSchemaTable.last();
+            int size = noSchemaTable.getRow();
+            assertEquals(
+                    "Does not support empty string as input parameter or Wildcard %",
+                    5, size);
+
+
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            ResultSet noSchemaTable = meta.getColumns("", "", "%", "%");
+            assertNotNull(noSchemaTable);
+            noSchemaTable.last();
+            int size = noSchemaTable.getRow();
+            assertEquals(
+                    "Does not support double Wildcard '%' as input",
+                    6, size);
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getColumns(null, null,
+                    DatabaseCreator.TEST_TABLE1, "%");
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+    
+    
+    
+    /**
+     * @tests java.sql.DatabaseMetaData #getColumns(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String)
+     *           
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "tests for specific tables. test fails: invalid nullable value.",
+        method = "getColumns",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Wildcard operator does not seem wo work correctly.")
+    public void test_getColumnsSpecific() throws SQLException {
+        String[] tablesName = {
+                DatabaseCreator.TEST_TABLE1, DatabaseCreator.TEST_TABLE3};
+        String[] fields = {"id", "field1", "field2", "field3", "fkey"};
+        String[] nullable = {"YES", "NO",""};
+        int[] nullableInt = {
+                DatabaseMetaData.columnNoNulls,
+                DatabaseMetaData.columnNullable,
+                DatabaseMetaData.columnNullableUnknown};
+        Arrays.sort(tablesName);
+        Arrays.sort(fields);
+        Arrays.sort(nullableInt);
+        Arrays.sort(nullable);
+        int countSingle = 0;
+        int countAll1 = 0;
+        int countAll2 = 0;
+        
+        try {
+            ResultSet rs = meta.getColumns(null, null,
+                    DatabaseCreator.TEST_TABLE1, "%");
+
+            while (rs.next()) {
+                assertTrue("Invalid table name", Arrays.binarySearch(
+                        tablesName, rs.getString("TABLE_NAME")) > -1);
+                assertTrue("Invalid field name", Arrays.binarySearch(fields, rs
+                        .getString("COLUMN_NAME")) > -1);
+                assertTrue("Invalid nullable value", Arrays.binarySearch(
+                        nullable, rs.getString("IS_NULLABLE")) > -1);
+                assertTrue("Invalid nullable code", Arrays.binarySearch(
+                        nullableInt, rs.getInt("NULLABLE")) > -1);
+                countSingle++;
+            }
+            assertEquals("Not all results are found", 5, countSingle);
+            rs.close();
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            ResultSet rs = meta.getColumns(null, null, "%"+DatabaseCreator.CREATE_TABLE1.substring(0, 3)+"%","%" );
+            while (rs.next()) {
+                assertTrue("Wrong table name", Arrays.binarySearch(tablesName,
+                        rs.getString("TABLE_NAME")) > -1);
+                countAll1++;
+            }
+            assertEquals("Not all results are found", 6, countAll1);
+            rs.close();
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            ResultSet rs = meta.getColumns(null, null, "%TEST_%", "%");
+
+            while (rs.next()) {
+                assertTrue("Wrong table name", Arrays.binarySearch(tablesName,
+                        rs.getString("TABLE_NAME")) > -1);
+                countAll2++;
+            }
+            assertEquals("Not all results are found", 6, countAll2);
+            rs.close();
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+     // Exception checking
+        conn.close();
+
+        try {
+            meta.getColumns(null, null,
+                    DatabaseCreator.TEST_TABLE1, "%");
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        
+    }
+    
+    
+     
+    /**
+     * @tests java.sql.DatabaseMetaData#getConnection()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getConnection",
+        args = {}
+    )
+    public void test_getConnection() throws SQLException {
+        assertEquals("Incorrect connection value", conn, meta.getConnection());
+     
+        // Exception checking
+        conn.close();
+
+        try {
+            Connection con = meta.getConnection();
+            assertTrue(con.isClosed());
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getCrossReference(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Test fails: Foreign keys not supported",
+        method = "getCrossReference",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("(Ticket 91) Tables apply foreign key constraint. Catalogs not supported")
+    public void test_getCrossReferenceLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        ResultSet rs = meta.getCrossReference(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 14, col);
+        String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
+                "PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
+                "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
+                "UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
+                "DEFERRABILITY" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+//      TODO getCatalog is not supported 
+//        assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
+//                rs.getString("PKTABLE_CAT"));
+        assertEquals("Incorrect primary key table schema", "", rs
+                .getString("PKTABLE_SCHEM"));
+        assertEquals("Incorrect primary key table name",
+                DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
+        assertEquals("Incorrect primary key column name", "fkey", rs
+                .getString("PKCOLUMN_NAME"));
+        // TODO getCatalog is not supported
+//        assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
+//                rs.getString("FKTABLE_CAT"));
+        assertEquals("Incorrect foreign key table schema", "", rs
+                .getString("FKTABLE_SCHEM"));
+        assertEquals("Incorrect foreign key table name",
+                DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
+        assertEquals("Incorrect foreign key column name", "fk", rs
+                .getString("FKCOLUMN_NAME"));
+        assertEquals("Incorrect sequence number within foreign key", 1, rs
+                .getShort("KEY_SEQ"));
+        assertEquals("Incorrect update rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("UPDATE_RULE"));
+        assertEquals("Incorrect delete rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("DELETE_RULE"));
+        assertNull("Incorrect foreign key name", rs.getString("FK_NAME"));
+        assertNull("Incorrect primary key name", rs.getString("PK_NAME"));
+        assertEquals("Incorrect deferrability",
+                DatabaseMetaData.importedKeyNotDeferrable, rs
+                        .getShort("DEFERRABILITY"));
+        rs.close();
+        
+     // Exception checking
+        conn.close();
+
+        try {
+            meta.getCrossReference(conn.getCatalog(), null,
+                    DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
+                    DatabaseCreator.TEST_TABLE1);
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getCrossReference(conn.getCatalog(), null,
+                    DatabaseCreator.TEST_TABLE3, conn.getCatalog(), null,
+                    DatabaseCreator.TEST_TABLE1);
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDatabaseMajorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDatabaseMajorVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDatabaseMajorVersion() throws SQLException {
+        assertTrue("Incorrdct database major version", meta
+                .getDatabaseMajorVersion() >= 0);
+        /*
+     // Exception checking
+        conn.close();
+
+        try {
+            meta.getDatabaseMajorVersion();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDatabaseMinorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDatabaseMinorVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDatabaseMinorVersion() throws SQLException {
+        assertTrue("Incorrect database minor version", meta
+                .getDatabaseMinorVersion() >= 0);
+        
+        /*
+     // Exception checking
+        conn.close();
+
+        try {
+            meta.getDatabaseMinorVersion();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDatabaseProductName()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDatabaseProductName",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDatabaseProductName() throws SQLException {
+        assertTrue("Incorrect database product name", !"".equals(meta
+                .getDatabaseProductName().trim()));
+        
+        /*
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getDatabaseProductName();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDatabaseProductVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDatabaseProductVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDatabaseProductVersion() throws SQLException {
+        assertTrue("Incorrect database product version", !"".equals(meta
+                .getDatabaseProductVersion().trim()));
+        /*
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getDatabaseProductVersion();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDefaultTransactionIsolation()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDefaultTransactionIsolation",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDefaultTransactionIsolation() throws SQLException {
+        int defaultLevel = meta.getDefaultTransactionIsolation();
+        switch (defaultLevel) {
+        case Connection.TRANSACTION_NONE:
+        case Connection.TRANSACTION_READ_COMMITTED:
+        case Connection.TRANSACTION_READ_UNCOMMITTED:
+        case Connection.TRANSACTION_REPEATABLE_READ:
+        case Connection.TRANSACTION_SERIALIZABLE:
+            // these levels are OK
+            break;
+        default:
+            fail("Incorrect value of default transaction isolation level");
+        }
+        
+        /*
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getDefaultTransactionIsolation();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDriverMajorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDriverMajorVersion",
+        args = {}
+    )
+    public void test_getDriverMajorVersion()  throws SQLException {
+        assertTrue("Incorrect driver major version", meta
+                .getDriverMajorVersion() >= 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDriverMinorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDriverMinorVersion",
+        args = {}
+    )
+    public void test_getDriverMinorVersion() {
+        assertTrue("Incorrect driver minor version", meta
+                .getDriverMinorVersion() >= 0);
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDriverName()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getDriverName",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDriverName() throws SQLException {
+        String driverName = meta.getDriverName();
+        assertTrue("Incorrect driver name", driverName.trim().startsWith(
+                "SQLite"));
+        
+        /*
+        // Exception checking
+        conn.close();
+
+        try {
+            meta.getDriverName();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getDriverVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDriverVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getDriverVersion() throws SQLException {
+        assertTrue("Incorrect driver version", !"".equals(meta
+                .getDriverVersion().trim()));
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getDriverVersion();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         
+         */
+    }
+   
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getImportedKeys(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "Test fails: Keys are not supported",
+        method = "getImportedKeys",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Keys are not supported: Ticket 91")
+    public void test_getImportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        ResultSet rs = meta.getImportedKeys(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 14, col);
+        String[] columnNames = { "PKTABLE_CAT", "PKTABLE_SCHEM",
+                "PKTABLE_NAME", "PKCOLUMN_NAME", "FKTABLE_CAT",
+                "FKTABLE_SCHEM", "FKTABLE_NAME", "FKCOLUMN_NAME", "KEY_SEQ",
+                "UPDATE_RULE", "DELETE_RULE", "FK_NAME", "PK_NAME",
+                "DEFERRABILITY" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+//      TODO getCatalog is not supported
+//        assertEquals("Incorrect primary key table catalog", conn.getCatalog(),
+//                rs.getString("PKTABLE_CAT"));
+        assertEquals("Incorrect primary key table schema", "", rs
+                .getString("PKTABLE_SCHEM"));
+        assertEquals("Incorrect primary key table name",
+                DatabaseCreator.TEST_TABLE3, rs.getString("PKTABLE_NAME"));
+        assertEquals("Incorrect primary key column name", "fkey", rs
+                .getString("PKCOLUMN_NAME"));
+//        assertEquals("Incorrect foreign key table catalog", conn.getCatalog(),
+//                rs.getString("FKTABLE_CAT"));
+        assertEquals("Incorrect foreign key table schema", "", rs
+                .getString("FKTABLE_SCHEM"));
+        assertEquals("Incorrect foreign key table name",
+                DatabaseCreator.TEST_TABLE1, rs.getString("FKTABLE_NAME"));
+        assertEquals("Incorrect foreign key column name", "fk", rs
+                .getString("FKCOLUMN_NAME"));
+        assertEquals("Incorrect sequence number within foreign key", 1, rs
+                .getShort("KEY_SEQ"));
+        assertEquals("Incorrect update rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("UPDATE_RULE"));
+        assertEquals("Incorrect delete rule value",
+                DatabaseMetaData.importedKeyNoAction, rs
+                        .getShort("DELETE_RULE"));
+ //       assertNotNull("Incorrect foreign key name", rs.getString("FK_NAME"));
+        assertEquals("Incorrect primary key name", null, rs
+                .getString("PK_NAME"));
+        assertEquals("Incorrect deferrability",
+                DatabaseMetaData.importedKeyNotDeferrable, rs
+                        .getShort("DEFERRABILITY"));
+        rs.close();
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getImportedKeys(conn.getCatalog(), null,
+                     DatabaseCreator.TEST_TABLE1);
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getMaxCursorNameLength()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMaxCursorNameLength",
+        args = {}
+    )
+    public void test_getMaxCursorNameLength() throws SQLException {
+        int nameLength = meta.getMaxCursorNameLength();
+        if (nameLength > 0) {
+            try {
+                statement.setCursorName(new String(new byte[nameLength + 1]));
+                fail("Expected SQLException was not thrown");
+            } catch (SQLException e) {
+                // expected
+            }
+        } else if (nameLength < 0) {
+            fail("Incorrect length of cursor name");
+        }
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getJDBCMinorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getJDBCMinorVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getJDBCMinorVersion() throws SQLException {
+        assertTrue("Incorrect JDBC minor version",
+                meta.getJDBCMinorVersion() >= 0);
+      /*  
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getJDBCMinorVersion();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getJDBCMajorVersion()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getJDBCMajorVersion",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getJDBCMajorVersion() throws SQLException {
+        assertTrue("Incorrect JDBC major version",
+                meta.getJDBCMajorVersion() >= 0);
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getJDBCMajorVersion();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getNumericFunctions()
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Test fails. Not implemented correctly. SQLException checking test fails",
+        method = "getNumericFunctions",
+        args = {}
+    )
+    @KnownFailure("Not supported feature, Ticket 98. Broken because "+
+            "NUMERIC_FUNCTIONS not complete. When fixed change to @KnownFailure")
+    public void test_getNumericFunctions() throws SQLException {
+        escapedFunctions(NUMERIC_FUNCTIONS, meta.getNumericFunctions());
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getNumericFunctions();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getPrimaryKeys(java.lang.String,
+     *        java.lang.String, java.lang.String)
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Functionality test fails: keys and catalogs are not supported. SQLException checking test fails",
+        method = "getPrimaryKeys",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure(" Ticket 91 : relies on not supported features: getCatalog, keys")
+    public void test_getPrimaryKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
+            throws SQLException {
+        ResultSet rs = meta.getPrimaryKeys(conn.getCatalog(), null,
+                DatabaseCreator.TEST_TABLE1);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 6, col);
+        String[] columnNames = { "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME",
+                "COLUMN_NAME", "KEY_SEQ", "PK_NAME" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+//        assertEquals("Incorrect table catalogue", conn.getCatalog(), rs
+//                .getString("TABLE_CAT").toLowerCase());
+        assertEquals("Incorrect table schema", "", rs
+                .getString("TABLE_SCHEM"));
+        assertEquals("Incorrect table name", DatabaseCreator.TEST_TABLE1, rs
+                .getString("TABLE_NAME").toLowerCase());
+        assertEquals("Incorrect column name", "id", rs.getString("COLUMN_NAME")
+                .toLowerCase());
+        assertEquals("Incorrect sequence number", 1, rs.getShort("KEY_SEQ"));
+ //       assertEquals("Incorrect primary key name", "primary", rs.getString(
+ //               "PK_NAME").toLowerCase());
+        rs.close();
+        
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getPrimaryKeys(conn.getCatalog(), null,
+                     DatabaseCreator.TEST_TABLE1);
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getResultSetHoldability()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getResultSetHoldability",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getResultSetHoldability() throws SQLException {
+        int hdb = meta.getResultSetHoldability();
+        switch (hdb) {
+        case ResultSet.HOLD_CURSORS_OVER_COMMIT:
+        case ResultSet.CLOSE_CURSORS_AT_COMMIT:
+            // these holdabilities are OK
+            break;
+        default:
+            fail("Incorrect value of holdability");
+        }
+        assertFalse("Incorrect result set holdability", meta
+                .supportsResultSetHoldability(hdb));
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getResultSetHoldability();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getSQLKeywords()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getSQLKeywords",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getSQLKeywords() throws SQLException {
+        assertTrue("Incorrect SQL keywords", !"".equals(meta.getSQLKeywords()
+                .trim()));
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSQLKeywords();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getSQLStateType()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getSQLStateType",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getSQLStateType() throws SQLException {
+        int type = meta.getSQLStateType();
+        switch (type) {
+        case DatabaseMetaData.sqlStateSQL99:
+        case DatabaseMetaData.sqlStateXOpen:
+            // these types are OK
+            break;
+        default:
+            fail("Incorrect SQL state types");
+        }
+        
+        /*
+        //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSQLStateType();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getSchemas()
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getSchemas",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getSchemas() throws SQLException {
+        ResultSet rs = meta.getSchemas();
+        ResultSetMetaData rsmd = rs.getMetaData();
+        assertTrue("Rows do not obtained", rs.next());
+        int col = rsmd.getColumnCount();
+        assertEquals("Incorrect number of columns", 1, col);
+        String[] columnNames = { "TABLE_SCHEM", "TABLE_CATALOG" };
+        for (int c = 1; c <= col; ++c) {
+            assertEquals("Incorrect column name", columnNames[c - 1], rsmd
+                    .getColumnName(c));
+        }
+        rs.close();
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSchemas();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getSearchStringEscape()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getSearchStringEscape",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getSearchStringEscape() throws SQLException {
+        assertTrue("Incorrect search string escape", !"".equals(meta
+                .getSearchStringEscape().trim()));
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSearchStringEscape();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getStringFunctions()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Functionality test fails. SQLException checking test fails",
+        method = "getStringFunctions",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void test_getStringFunctions() throws SQLException {
+        escapedFunctions(STRING_FUNCTIONS, meta.getStringFunctions());
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getStringFunctions();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+        
+    }
+
+  
+    /**
+     * @tests java.sql.DatabaseMetaData#getSystemFunctions()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Functionality test fails. SQLException checking test fails",
+        method = "getSystemFunctions",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void test_getSystemFunctions() throws SQLException {
+        escapedFunctions(SYSTEM_FUNCTIONS, meta.getSystemFunctions());
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getSystemFunctions();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+   
+    /**
+     * @tests java.sql.DatabaseMetaData#getTableTypes()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getTableTypes",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getTableTypes() throws SQLException {
+        String[] tableTypes = { "LOCAL TEMPORARY", "TABLE", "VIEW" };
+        ResultSet rs = meta.getTableTypes();
+
+        while (rs.next()) {
+            assertTrue("Wrong table type", Arrays.binarySearch(tableTypes, rs
+                    .getString("TABLE_TYPE")) > -1);
+        }
+        rs.close();
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getTableTypes();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData #getTables(java.lang.String,
+     *        java.lang.String, java.lang.String, java.lang.String[])
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Test fails.",
+        method = "getTables",
+        args = {java.lang.String.class, java.lang.String.class, java.lang.String.class, java.lang.String[].class}
+    )
+    @KnownFailure("If no schema is associated: returns empty string or shouldn't null be returned?. Ticket 98")
+    public void test_getTablesLjava_lang_StringLjava_lang_StringLjava_lang_String$Ljava_lang_String()
+            throws SQLException {
+        String[] tablesName = {
+                VIEW_NAME, DatabaseCreator.TEST_TABLE1,
+                DatabaseCreator.TEST_TABLE3};
+        String[] tablesType = {"TABLE", "VIEW"};
+        Arrays.sort(tablesName);
+        Arrays.sort(tablesType);
+
+        // case 1. get all tables. There are two tables and one view in the
+        // database
+        ResultSet rs = meta.getTables(null, null, null, null);
+        while (rs.next()) {
+            assertTrue("Wrong table name", Arrays.binarySearch(tablesName, rs
+                    .getString("TABLE_NAME")) > -1);
+        //No Schema associated    
+//            assertNull("Wrong table schema: "+rs.getString("TABLE_SCHEM"), rs.getString("TABLE_SCHEM"));
+            assertTrue("Wrong table type", Arrays.binarySearch(tablesType, rs
+                    .getString("TABLE_TYPE")) > -1);
+            assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
+        }
+        rs.close();
+
+        // case 2. get tables with specified types. There are no tables of such
+        // types
+        rs = meta.getTables(conn.getCatalog(), null, null, new String[] {
+                "SYSTEM TABLE", "LOCAL TEMPORARY" });
+        assertFalse("Some tables exist", rs.next());
+        rs.close();
+
+        // case 3. get tables with specified types. There is a table of such
+        // types
+        rs = meta.getTables(conn.getCatalog(), null, null, new String[] {
+                "VIEW", "LOCAL TEMPORARY" });
+
+        assertTrue("No tables exist", rs.next());
+        assertEquals("Wrong table name", VIEW_NAME, rs.getString("TABLE_NAME"));
+//        assertNull("Wrong table schema: "+rs.getString("TABLE_SCHEM"), rs.getString("TABLE_SCHEM"));
+        assertEquals("Wrong table type", "VIEW", rs.getString("TABLE_TYPE"));
+        assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
+        assertFalse("Wrong size of result set", rs.next());
+        assertFalse("Some tables exist", rs.next());
+        rs.close();
+
+        // case 4. get all tables using tables pattern.
+        // There are two tables and one view in the database
+        rs = meta.getTables(null, null, "%", null);
+
+        while (rs.next()) {
+            assertTrue("Wrong table name", Arrays.binarySearch(tablesName, rs
+                    .getString("TABLE_NAME")) > -1);
+//            assertNull("Wrong table schema ", rs.getString("TABLE_SCHEM"));
+            assertTrue("Wrong table type", Arrays.binarySearch(tablesType, rs
+                    .getString("TABLE_TYPE")) > -1);
+            assertEquals("Wrong parameter REMARKS", "", rs.getString("REMARKS"));
+        }
+        rs.close();
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getTables(null, null, null, null);
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getTimeDateFunctions()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Does not return any functions. test fails. SQLException checking test fails",
+        method = "getTimeDateFunctions",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void test_getTimeDateFunctions() throws SQLException {
+        
+        escapedFunctions(TIMEDATE_FUNCTIONS, meta.getTimeDateFunctions());
+        
+        /*
+        //Exception checking
+        conn.close();
+         
+         try {
+             meta.getTimeDateFunctions();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+        */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getTypeInfo()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getTypeInfo",
+        args = {}
+    )
+    public void test_getTypeInfo() throws SQLException {
+        insertNewRecord();
+
+        ResultSet rs = meta.getTypeInfo();
+
+        final String[] names = { "TYPE_NAME", "DATA_TYPE", "PRECISION",
+                "LITERAL_PREFIX", "LITERAL_SUFFIX", "CREATE_PARAMS",
+                "NULLABLE", "CASE_SENSITIVE", "SEARCHABLE",
+                "UNSIGNED_ATTRIBUTE", "FIXED_PREC_SCALE", "AUTO_INCREMENT",
+                "LOCAL_TYPE_NAME", "MINIMUM_SCALE", "MAXIMUM_SCALE",
+                "SQL_DATA_TYPE", "SQL_DATETIME_SUB", "NUM_PREC_RADIX" };
+        Arrays.sort(names);
+
+        for (int i = 0; i < rs.getMetaData().getColumnCount(); i++) {
+            assertTrue("wrong column was return", Arrays.binarySearch(names, rs
+                    .getMetaData().getColumnName(i + 1)) > -1);
+        }
+
+        int[] types = { Types.ARRAY, Types.BIGINT, Types.BINARY, Types.BIT,
+                Types.BLOB, Types.BOOLEAN, Types.CHAR, Types.CLOB,
+                Types.DATALINK, Types.DATE, Types.DECIMAL, Types.DISTINCT,
+                Types.DOUBLE, Types.FLOAT, Types.INTEGER, Types.JAVA_OBJECT,
+                Types.LONGVARBINARY, Types.LONGVARCHAR, Types.NULL,
+                Types.NUMERIC, Types.OTHER, Types.REAL, Types.REF,
+                Types.SMALLINT, Types.STRUCT, Types.TIME, Types.TIMESTAMP,
+                Types.TINYINT, Types.VARBINARY, Types.VARCHAR };
+        Arrays.sort(types);
+
+        while (rs.next()) {
+            assertTrue("wrong type was return ", Arrays.binarySearch(types, rs
+                    .getInt("DATA_TYPE")) > -1);
+        }
+        rs.close();
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getTypeInfo();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+
+    /**
+     * @tests java.sql.DatabaseMetaData#getURL()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getURL",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_getURL() throws SQLException {
+        assertEquals("Wrong url", Support_SQL.sqlUrl, meta.getURL());
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getURL();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#getUserName()
+     * 
+     *  NOT_FEASIBLE not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getUserName",
+        args = {}
+    )
+     @KnownFailure("Ticket 98")
+    public void test_getUserName() throws SQLException {
+      assertEquals("Wrong user name", Support_SQL.sqlUser, meta.getUserName());
+      /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.getUserName();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+
+    /**
+     * @tests java.sql.DatabaseMetaData#insertsAreDetected(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "insertsAreDetected",
+        args = {int.class}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_insertsAreDetectedI() throws SQLException {
+        assertFalse(
+                "visible row insert can be detected for TYPE_FORWARD_ONLY type",
+                meta.insertsAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "visible row insert can be detected for TYPE_SCROLL_INSENSITIVE type",
+                meta.insertsAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "visible row insert can be detected for TYPE_SCROLL_SENSITIVE type",
+                meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
+        
+        /*
+        //Exception checking
+        conn.close();
+         
+         try {
+             meta.insertsAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE);
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#isReadOnly()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "isReadOnly",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_isReadOnly() throws SQLException {
+        assertFalse("database is not read-only", meta.isReadOnly());
+        
+      /*  
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.isReadOnly();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+       */
+    }
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#othersDeletesAreVisible(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails.",
+        method = "othersDeletesAreVisible",
+        args = {int.class}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_othersDeletesAreVisibleI() throws SQLException {
+        assertFalse(
+                "deletes made by others are visible for TYPE_FORWARD_ONLY type",
+                meta.othersDeletesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "deletes made by others are visible for TYPE_SCROLL_INSENSITIVE type",
+                meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "deletes made by others are visible for TYPE_SCROLL_SENSITIVE type",
+                meta.othersDeletesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+       
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             assertFalse("inserts made by others are visible for unknown type", meta
+                     .othersDeletesAreVisible(ResultSet.CONCUR_READ_ONLY));
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#othersInsertsAreVisible(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "othersInsertsAreVisible",
+        args = {int.class}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_othersInsertsAreVisibleI() throws SQLException {
+        assertFalse(
+                "inserts made by others are visible for TYPE_FORWARD_ONLY type",
+                meta.othersInsertsAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "inserts made by others are visible for TYPE_SCROLL_INSENSITIVE type",
+                meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "inserts made by others are visible for TYPE_SCROLL_SENSITIVE type",
+                meta.othersInsertsAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        
+       /* 
+      //Exception checking
+        conn.close();
+         
+         try {
+             assertFalse("inserts made by others are visible for unknown type", meta
+                     .othersInsertsAreVisible(ResultSet.CONCUR_READ_ONLY));
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#othersUpdatesAreVisible(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = " Verification with invalid parameters missed.",
+        method = "othersUpdatesAreVisible",
+        args = {int.class}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_othersUpdatesAreVisibleI() throws SQLException {
+        assertFalse(
+                "updates made by others are visible for TYPE_FORWARD_ONLY type",
+                meta.othersUpdatesAreVisible(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "updates made by others are visible for TYPE_SCROLL_INSENSITIVE type",
+                meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "updates made by others are visible for TYPE_SCROLL_SENSITIVE type",
+                meta.othersUpdatesAreVisible(ResultSet.TYPE_SCROLL_SENSITIVE));
+        
+      //Exception checking
+         
+         try {
+             assertFalse("updates made by others are visible for unknown type", meta
+                     .othersUpdatesAreVisible(ResultSet.CONCUR_READ_ONLY));
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#storesMixedCaseQuotedIdentifiers()
+     */
+    @TestTargets ({
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "storesMixedCaseQuotedIdentifiers",
+        args = {}
+    ),
+    @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "SQLException checking test fails",
+            method = "storesMixedCaseIdentifiers",
+            args = {}
+        )
+    })
+    public void test_storesMixedCaseQuotedIdentifiers() throws SQLException {
+        String quote = meta.getIdentifierQuoteString();
+        
+        
+        
+        insertNewRecord();
+
+        String selectQuery = "SELECT " + quote + "fieLD1" + quote + " FROM "
+                + DatabaseCreator.TEST_TABLE1;
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.storesMixedCaseIdentifiers()) {
+                fail("mixed case is supported");
+            }
+        } catch (SQLException e) {
+            if (meta.storesMixedCaseQuotedIdentifiers()) {
+                fail("quoted case is not supported");
+            }
+        }
+        
+        //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.storesMixedCaseIdentifiers();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         
+         conn.close();
+         
+         try {
+             meta.storesMixedCaseQuotedIdentifiers();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+    
+    @TestTargetNew(
+      level = TestLevel.COMPLETE,
+      notes = "Exception test fails.",
+      method = "getIdentifierQuoteString",
+      args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void testGetIdentifierQuoteString() throws SQLException {
+       assertNotNull(
+               meta.getIdentifierQuoteString()
+               );
+       
+       //Exception test
+       /*
+       conn.close();
+       try {
+           meta.getIdentifierQuoteString();
+           fail("Should throw exception");
+       } catch (SQLException e) {
+           //ok
+       }
+       */
+       
+    }
+
+   
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsColumnAliasing()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsColumnAliasing",
+        args = {}
+    )
+    public void test_supportsColumnAliasing() throws SQLException {
+        insertNewRecord();
+
+        String alias = "FIELD3";
+        String selectQuery = "SELECT field1 AS " + alias + " FROM "
+                + DatabaseCreator.TEST_TABLE1;
+        ResultSet rs = statement.executeQuery(selectQuery);
+        ResultSetMetaData rsmd = rs.getMetaData();
+
+        if (meta.supportsColumnAliasing()) {
+            // supports aliasing
+            assertEquals("Wrong count of columns", 1, rsmd.getColumnCount());
+            assertEquals("Aliasing is not supported", alias, rsmd
+                    .getColumnLabel(1));
+        } else {
+            // doesn't support aliasing
+            assertEquals("Aliasing is supported", 0, rsmd.getColumnCount());
+        }
+        rs.close();
+        
+      //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsColumnAliasing();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsExpressionsInOrderBy()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsExpressionsInOrderBy",
+        args = {}
+    )
+    public void test_supportsExpressionsInOrderBy() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+                + " ORDER BY id + field3";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsExpressionsInOrderBy()) {
+                fail("Expressions in order by are supported");
+            }
+        } catch (SQLException e) {
+            if (meta.supportsExpressionsInOrderBy()) {
+                fail("Expressions in order by are not supported");
+            }
+        }
+        
+      //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsExpressionsInOrderBy();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsGroupBy()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsGroupBy",
+        args = {}
+    )
+    public void test_supportsGroupBy() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+                + " GROUP BY field3";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsGroupBy()) {
+                fail("group by are supported");
+            }
+        } catch (SQLException e) {
+            if (meta.supportsGroupBy()) {
+                fail("group by are not supported");
+            }
+        }
+        
+      //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsGroupBy();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+   
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsGroupByUnrelated()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsGroupByUnrelated",
+        args = {}
+    )
+    public void test_supportsGroupByUnrelated() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT field1, field2 FROM "
+                + DatabaseCreator.TEST_TABLE1 + " GROUP BY field3";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsGroupByUnrelated()) {
+                fail("unrelated columns in group by are supported");
+            }
+        } catch (SQLException e) {
+            if (meta.supportsGroupByUnrelated()) {
+                fail("unrelated columns in group by are not supported");
+            }
+        }
+       
+        //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsGroupByUnrelated();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsNonNullableColumns()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException thrown",
+        method = "supportsNonNullableColumns",
+        args = {}
+    )
+    @KnownFailure("Ticket 98")
+    public void test_supportsNonNullableColumns() throws SQLException {
+        assertTrue(
+                "columns in this database may not be defined as non-nullable",
+                meta.supportsNonNullableColumns());
+        statementForward.execute("create table companies(id integer not null);");
+        statementForward.execute("drop table companies");
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.supportsNonNullableColumns();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsOrderByUnrelated()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsOrderByUnrelated",
+        args = {}
+    )
+    public void test_supportsOrderByUnrelated() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT field1, field2 FROM "
+                + DatabaseCreator.TEST_TABLE1 + " ORDER BY id + field3";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsOrderByUnrelated()) {
+                fail("unrelated columns in order by are supported");
+            }
+        } catch (SQLException e) {
+            if (meta.supportsOrderByUnrelated()) {
+                fail("unrelated columns in order by are not supported");
+            }
+        }
+        
+      //Exception checking
+        
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsOrderByUnrelated();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSelectForUpdate()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsSelectForUpdate",
+        args = {}
+    )
+    public void test_supportsSelectForUpdate() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT field1 FROM "
+                + DatabaseCreator.TEST_TABLE1 + " FOR UPDATE";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsSelectForUpdate()) {
+                fail("select for update are supported");
+            }
+        } catch (SQLException e) {
+            if (!meta.supportsSelectForUpdate()) {
+                fail("select for update are not supported");
+            }
+        }
+        
+        
+      //Exception checking
+        /*
+        conn.close();
+         
+         try {
+             meta.supportsSelectForUpdate();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsSubqueriesInExists()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsSubqueriesInExists",
+        args = {}
+    )
+    public void test_supportsSubqueriesInExists() throws SQLException {
+        insertNewRecord();
+
+        String selectQuery = "SELECT field1 FROM "
+                + DatabaseCreator.TEST_TABLE1
+                + " WHERE EXISTS(SELECT field2 FROM "
+                + DatabaseCreator.TEST_TABLE1 + ")";
+
+        try {
+            statement.executeQuery(selectQuery);
+            if (!meta.supportsSubqueriesInExists()) {
+                fail("Subqueries in exists are supported");
+            }
+        } catch (SQLException e) {
+            if (meta.supportsSubqueriesInExists()) {
+                fail("Subqueries in exists are not supported");
+            }
+        }
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.supportsSubqueriesInExists();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsTableCorrelationNames()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "supportsTableCorrelationNames",
+        args = {}
+    )
+    public void test_supportsTableCorrelationNames() throws SQLException {
+        
+        insertNewRecord();
+        assertFalse(conn.isClosed());
+        
+        String corelationName = "TABLE_NAME";
+        String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+                + " AS " + corelationName;
+        ResultSet rs = statementForward.executeQuery(selectQuery);
+        ResultSetMetaData rsmd = rs.getMetaData();
+        int numOfColumn = rsmd.getColumnCount();
+
+        for (int i = 0; i < numOfColumn; i++) {
+            if (meta.supportsTableCorrelationNames()) {
+                assertEquals("Corelation names is now supported",
+                        corelationName, rsmd.getTableName(i + 1));
+            } else {
+                assertEquals("Corelation names is supported",
+                        DatabaseCreator.TEST_TABLE1, rsmd.getTableName(i + 1));
+            }
+        }
+        
+        /*
+      //Exception checking
+        conn.close();
+         
+         try {
+             meta.supportsTableCorrelationNames();
+             fail("SQLException not thrown");
+         } catch (SQLException e) {
+             //ok
+         }
+         */
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#supportsTransactionIsolationLevel(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = " Not all Transaction isolation levels supported.",
+        method = "supportsTransactionIsolationLevel",
+        args = {int.class}
+    )
+    public void test_supportsTransactionIsolationLevelI() throws SQLException {
+        assertFalse("database supports TRANSACTION_NONE isolation level", meta
+                .supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
+        // TODO only Connection.TRANSACTION_SERIALIZABLE is supported
+//        assertTrue(
+//                "database doesn't supports TRANSACTION_READ_COMMITTED isolation level",
+//                meta
+//                        .supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_COMMITTED));
+//        assertTrue(
+//                "database doesn't supports TRANSACTION_READ_UNCOMMITTED isolation level",
+//                meta
+//                        .supportsTransactionIsolationLevel(Connection.TRANSACTION_READ_UNCOMMITTED));
+//        assertTrue(
+//               "database doesn't supports TRANSACTION_REPEATABLE_READ isolation level",
+//                meta
+//                        .supportsTransactionIsolationLevel(Connection.TRANSACTION_REPEATABLE_READ));
+        assertTrue(
+                "database doesn't supports TRANSACTION_SERIALIZABLE isolation level",
+                meta
+                        .supportsTransactionIsolationLevel(Connection.TRANSACTION_SERIALIZABLE));
+        
+        
+      //Exception checking
+         
+         try {
+             assertFalse("database supports unknown isolation level", meta
+                     .supportsTransactionIsolationLevel(Integer.MAX_VALUE));;
+         } catch (SQLException e) {
+             //ok
+         }
+    }
+
+    /**
+     * @tests java.sql.DatabaseMetaData#updatesAreDetected(int)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = " Verification with invalid parameters missed.",
+        method = "updatesAreDetected",
+        args = {int.class}
+    )
+    public void test_updatesAreDetectedI() throws SQLException {
+        assertFalse(
+                "visible row update can be detected for TYPE_FORWARD_ONLY type",
+                meta.updatesAreDetected(ResultSet.TYPE_FORWARD_ONLY));
+        assertFalse(
+                "visible row update can be detected for TYPE_SCROLL_INSENSITIVE type",
+                meta.updatesAreDetected(ResultSet.TYPE_SCROLL_INSENSITIVE));
+        assertFalse(
+                "visible row update can be detected for TYPE_SCROLL_SENSITIVE type",
+                meta.updatesAreDetected(ResultSet.TYPE_SCROLL_SENSITIVE));
+        assertFalse("visible row update can be detected for unknown type", meta
+                .updatesAreDetected(100));
+        
+        //Exception checking
+       conn.close();
+        
+        try {
+            meta.updatesAreDetected(ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            assertFalse("visible row update can be detected for unknown type", meta
+                    .updatesAreDetected(ResultSet.CLOSE_CURSORS_AT_COMMIT));
+            
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+
+    protected static void insertNewRecord() throws SQLException {
+        if (conn.isClosed()) {
+            System.out.println("DatabaseMetaDataTest.insertNewRecord() : closed");
+        }
+        
+        String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE1
+                + " (id, field1, field2, field3) VALUES(" + id + ", '"
+                + "value" + id + "', " + id + ", " + id + ")";
+        id++;
+        statement.execute(insertQuery);
+    }
+    
+    //BEGIN APACHE-DERBY
+    
+    /**
+     * Test Method from Apache Derby Project
+     * Class 
+     * org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
+     *  
+     * Compare a ResultSet from getColumns() with ResultSetMetaData returned
+     * from a SELECT * against the table. This method handles situations where a
+     * full set of the columns are in the ResultSet. The first action is to call
+     * rs.next(). The ResultSet will be closed by this method.
+     * 
+     * @param rs
+     *            resultset to crossCheck
+     * @param partial
+     *            used to indicate if ordinal position should get checked
+     * @return the number of rows in the resultSet
+     * @throws SQLException
+     */
+    private int crossCheckGetColumnsAndResultSetMetaData(ResultSet rs,
+            boolean partial)
+    throws SQLException
+    {
+        Statement s = conn.createStatement();
+        while (rs.next())
+        {
+            String schema = rs.getString("TABLE_SCHEM");
+            String table = rs.getString("TABLE_NAME");
+            
+            ResultSet rst = s.executeQuery(
+                "SELECT * FROM " + schema+"."+table);
+            ResultSetMetaData rsmdt = rst.getMetaData();
+
+                     
+            for (int col = 1; col <= rsmdt.getColumnCount() ; col++)
+            {
+                if (!partial) {
+                    if (col != 1)
+                        assertTrue(rs.next());
+                
+                    assertEquals("ORDINAL_POSITION",
+                            col, rs.getInt("ORDINAL_POSITION"));
+                }
+                
+                assertEquals("TABLE_CAT",
+                        "", rs.getString("TABLE_CAT"));
+                assertEquals("TABLE_SCHEM",
+                        schema, rs.getString("TABLE_SCHEM"));
+                assertEquals("TABLE_NAME",
+                        table, rs.getString("TABLE_NAME"));
+                
+                crossCheckGetColumnRowAndResultSetMetaData(rs, rsmdt);
+                if (partial)
+                    break;
+                
+            }
+            rst.close();
+            
+            
+        }
+        int count = rs.getRow();
+        rs.close();
+        s.close();
+        return count;
+    }
+    
+    /**
+     * * Test Method from Apache Derby Project
+     * Class 
+     * org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
+     * 
+     * Cross check a single row from getColumns() with ResultSetMetaData
+     * for a SELECT * from the same table.
+     * @param rs ResultSet from getColumns already positioned on the row.
+     * @param rsmdt ResultSetMetaData for the SELECT *
+     * @param odbc 0 for JDBC call, 1 for ODBC. Needed to allow for difference
+     *    in using BUFFER_LENGTH (ODBC) or no(JDBC).
+     * @throws SQLException
+     */
+    public static void crossCheckGetColumnRowAndResultSetMetaData(
+            ResultSet rs, ResultSetMetaData rsmdt)
+        throws SQLException
+    {
+        int col = rs.getInt("ORDINAL_POSITION");
+        
+        assertEquals("RSMD.getCatalogName",
+                rsmdt.getCatalogName(col), rs.getString("TABLE_CAT"));
+        assertEquals("RSMD.getSchemaName",
+                rsmdt.getSchemaName(col), rs.getString("TABLE_SCHEM"));
+        assertEquals("RSMD.getTableName",
+                rsmdt.getTableName(col), rs.getString("TABLE_NAME"));
+        
+        assertEquals("COLUMN_NAME",
+                rsmdt.getColumnName(col), rs.getString("COLUMN_NAME"));
+        
+        // DERBY-2285 BOOLEAN columns appear different on
+        // network client.
+        // meta returns BOOLEAN
+        // RSMD returns SMALLINT
+        int metaColumnType = rs.getInt("DATA_TYPE");
+        if (metaColumnType == Types.BOOLEAN )
+        {
+            assertEquals("TYPE_NAME",
+                    "BOOLEAN", rs.getString("TYPE_NAME"));
+            assertEquals("TYPE_NAME",
+                    "SMALLINT", rsmdt.getColumnTypeName(col));
+
+            assertEquals("DATA_TYPE",
+                    Types.SMALLINT, rsmdt.getColumnType(col));
+        }
+        else if (metaColumnType == Types.JAVA_OBJECT)
+        {
+            // meta returns JAVA_OBJECT
+            // RSMD returns LONGVARBINARY!                    
+            assertEquals("DATA_TYPE",
+                    Types.LONGVARBINARY, rsmdt.getColumnType(col));                   
+        }
+        else if (metaColumnType == Types.VARBINARY )
+        {
+            // meta returns different type name to RSMD
+            assertEquals("DATA_TYPE",
+                    Types.VARBINARY, rsmdt.getColumnType(col));  
+        }
+        else if (metaColumnType == Types.BINARY )
+        {
+            // meta returns different type name to RSMD
+            assertEquals("DATA_TYPE",
+                    Types.BINARY, rsmdt.getColumnType(col));                               
+        }
+        else if (metaColumnType == Types.NUMERIC )
+        {
+            // DERBY-584 inconsistency in numeric & decimal
+            assertEquals("DATA_TYPE",
+                    Types.DECIMAL, rsmdt.getColumnType(col));
+            
+            assertEquals("TYPE_NAME",
+                    "DECIMAL", rsmdt.getColumnTypeName(col));
+                       
+            assertEquals("TYPE_NAME",
+                    "NUMERIC", rs.getString("TYPE_NAME"));
+        }
+        else
+        {
+            assertEquals("DATA_TYPE",
+                rsmdt.getColumnType(col), rs.getInt("DATA_TYPE"));
+            assertEquals("TYPE_NAME",
+                rsmdt.getColumnTypeName(col), rs.getString("TYPE_NAME"));
+        }
+        
+        /*
+        if (metaColumnType != Types.JAVA_OBJECT) {
+        System.out.println("TYPE " + rs.getInt("DATA_TYPE"));
+        System.out.println(JDBC.escape(schema, table) + " " + rs.getString("COLUMN_NAME"));
+        assertEquals("COLUMN_SIZE",
+                rsmdt.getPrecision(col), rs.getInt("COLUMN_SIZE"));
+        }
+        */
+        
+        /*
+        assertEquals("DECIMAL_DIGITS",
+                rsmdt.getScale(col), rs.getInt("DECIMAL_DIGITS"));
+        */
+        
+        // This assumes the constants defined by meta and ResultSet
+        // for nullability are equal. They are by inspection
+        // and since they are static final and part of a defined
+        // api by definition they cannot change. We also
+        // check statically this is true in the testConstants fixture.
+        assertEquals("NULLABLE",
+                rsmdt.isNullable(col), rs.getInt("NULLABLE"));
+        
+        // REMARKS set to empty string by Derby
+        assertEquals("REMARKS", "", rs.getString("REMARKS"));
+        
+        
+        // IS_NULLABLE
+        switch (rsmdt.isNullable(col))
+        {
+        case ResultSetMetaData.columnNoNulls:
+            assertEquals("IS_NULLABLE", "NO", rs.getString("IS_NULLABLE"));
+            break;
+        case ResultSetMetaData.columnNullable:
+            assertEquals("IS_NULLABLE", "YES", rs.getString("IS_NULLABLE"));
+            break;
+        case ResultSetMetaData.columnNullableUnknown:
+            assertEquals("IS_NULLABLE", "", rs.getString("IS_NULLABLE"));
+            break;
+        default:
+            fail("invalid return from rsmdt.isNullable(col)");
+        }
+        
+        // SCOPE not supported
+        assertNull("SCOPE_CATLOG", rs.getString("SCOPE_CATLOG"));
+        assertNull("SCOPE_SCHEMA", rs.getString("SCOPE_SCHEMA"));
+        assertNull("SCOPE_TABLE", rs.getString("SCOPE_TABLE"));
+        
+        // DISTINCT not supported
+        assertEquals("SOURCE_DATA_TYPE", 0, rs.getShort("SOURCE_DATA_TYPE"));
+        assertTrue(rs.wasNull());
+        
+        // IS_AUTOINCREMENT added in JDBC 4.0
+       assertEquals("IS_AUTOINCREMENT",
+               rsmdt.isAutoIncrement(col) ? "YES" : "NO",
+               rs.getString("IS_AUTOINCREMENT"));
+       assertFalse(rs.wasNull());        
+    }
+    
+    /*
+     * Check the shape of the ResultSet from any getColumns call.
+     */
+    private void checkColumnsShape(ResultSet rs) throws SQLException {
+        int[] columnTypes = new int[] {
+                Types.VARCHAR, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.SMALLINT, Types.VARCHAR, Types.INTEGER, Types.INTEGER,
+                Types.INTEGER, Types.INTEGER, Types.INTEGER, Types.VARCHAR,
+                Types.VARCHAR, Types.INTEGER, Types.INTEGER, Types.INTEGER,
+                Types.INTEGER, Types.VARCHAR, Types.VARCHAR, Types.VARCHAR,
+                Types.VARCHAR, Types.SMALLINT, Types.VARCHAR};
+
+        assertMetaDataResultSet(rs, new String[] {
+                "TABLE_CAT", "TABLE_SCHEM", "TABLE_NAME", "COLUMN_NAME",
+                "DATA_TYPE", "TYPE_NAME", "COLUMN_SIZE", "BUFFER_LENGTH",
+                "DECIMAL_DIGITS", "NUM_PREC_RADIX", "NULLABLE", "REMARKS",
+                "COLUMN_DEF", "SQL_DATA_TYPE", "SQL_DATETIME_SUB",
+                "CHAR_OCTET_LENGTH", "ORDINAL_POSITION", "IS_NULLABLE",
+                "SCOPE_CATLOG", "SCOPE_SCHEMA", "SCOPE_TABLE",
+                "SOURCE_DATA_TYPE", "IS_AUTOINCREMENT"}, columnTypes, null);
+
+    }
+    
+    public static void assertMetaDataResultSet(ResultSet rs,
+            String[] columnNames, int[] columnTypes,
+            boolean[] nullability) throws SQLException
+    {
+     // see ResultSetGetterTest, getType() -> this test fails currently  
+        assertEquals(ResultSet.TYPE_FORWARD_ONLY, rs.getType());
+        assertEquals(ResultSet.CONCUR_READ_ONLY, rs.getConcurrency());
+        
+        if (columnNames != null)
+            assertColumnNames(rs, columnNames);
+        if (columnTypes != null)
+            assertColumnTypes(rs, columnTypes);
+        if (nullability != null)
+            assertNullability(rs, nullability);
+    }
+    
+    /**
+     * * Test Method from Apache Derby Project
+     *   Class 
+     * org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
+     * 
+     * Takes a result set and an array of expected colum names (as
+     * Strings)  and asserts that the column names in the result
+     * set metadata match the number, order, and names of those
+     * in the array.
+     *
+     * @param rs ResultSet for which we're checking column names.
+     * @param expectedColNames Array of expected column names.
+     */
+    public static void assertColumnNames(ResultSet rs,
+        String [] expectedColNames) throws SQLException
+    {
+        ResultSetMetaData rsmd = rs.getMetaData();
+        int actualCols = rsmd.getColumnCount();
+
+        for (int i = 0; i < actualCols; i++)
+        {
+        assertEquals("Column names do not match:",
+                expectedColNames[i], rsmd.getColumnName(i+1));
+        }
+        
+        assertEquals("Unexpected column count:",
+        expectedColNames.length, rsmd.getColumnCount());
+    }
+    
+    /**
+     * Test Method from Apache Derby Project
+     * Class 
+     * org.apache.derbyTesting.functionTests.tests.jdbcapi.DatabaseMetaDataTest
+     * 
+     * Takes a result set and an array of expected column types
+     * from java.sql.Types 
+     * and asserts that the column types in the result
+     * set metadata match the number, order, and names of those
+     * in the array.
+     * 
+     * No length information for variable length types
+     * can be passed. For ResultSets from JDBC DatabaseMetaData
+     * the specification only indicates the types of the
+     * columns, not the length.
+     *
+     * @param rs ResultSet for which we're checking column names.
+     * @param expectedTypes Array of expected column types.
+     */
+    public static void assertColumnTypes(ResultSet rs,
+        int[] expectedTypes) throws SQLException
+    {
+        ResultSetMetaData rsmd = rs.getMetaData();
+        int actualCols = rsmd.getColumnCount();
+
+        assertEquals("Unexpected column count:",
+                expectedTypes.length, rsmd.getColumnCount());
+
+        for (int i = 0; i < actualCols; i++)
+        {
+       assertEquals("Column types do not match for column " + (i+1),
+                    expectedTypes[i], rsmd.getColumnType(i+1));
+        }
+    }
+    
+    /**
+     * Check the nullability of the column definitions for
+     * the ResultSet matches the expected values.
+     * @param rs
+     * @param nullability
+     * @throws SQLException 
+     */
+    public static void assertNullability(ResultSet rs,
+            boolean[] nullability) throws SQLException
+    {
+        ResultSetMetaData rsmd = rs.getMetaData();
+        int actualCols = rsmd.getColumnCount();
+
+        assertEquals("Unexpected column count:",
+                nullability.length, rsmd.getColumnCount());
+
+        for (int i = 0; i < actualCols; i++)
+        {
+            int expected = nullability[i] ?
+               ResultSetMetaData.columnNullable : ResultSetMetaData.columnNoNulls;
+       assertEquals("Column nullability do not match for column " + (i+1),
+                    expected, rsmd.isNullable(i+1));
+        }       
+    }
+    
+    //BEGIN Apache Derby DatabaseMetaDataTest
+
+     /*
+      * Escaped function testing TODO complete this list
+      */
+     private static final String[][] NUMERIC_FUNCTIONS = {
+             // Section C.1 JDBC 3.0 spec.
+             {"ABS", "-25.67"}, 
+             
+//             {"ACOS", "0.0707"}, {"ASIN", "0.997"},
+//             {"ATAN", "14.10"}, {"ATAN2", "0.56", "1.2"}, {"CEILING", "3.45"},
+//             {"COS", "1.2"}, {"COT", "3.4"}, {"DEGREES", "2.1"}, {"EXP", "2.3"},
+//             {"FLOOR", "3.22"}, {"LOG", "34.1"}, {"LOG10", "18.7"},
+//             {"MOD", "124", "7"}, {"PI"}, {"POWER", "2", "3"},
+//             {"RADIANS", "54"}, {"RAND", "17"}, 
+             
+             {"ROUND", "345.345", "1"}
+             
+//             {"SIGN", "-34"}, {"SIN", "0.32"}, {"SQRT", "6.22"},
+//             {"TAN", "0.57",}, {"TRUNCATE", "345.395", "1"}
+             
+             };
+
+     private static final String[][] TIMEDATE_FUNCTIONS = {
+             // Section C.3 JDBC 3.0 spec.
+         
+             {"date","'now'"}
+             
+             //TODO Complete list
+
+     };
+
+     private static final String[][] SYSTEM_FUNCTIONS = {
+     // Section C.4 JDBC 3.0 spec.
+             {"IFNULL", "'this'", "'that'"}, {"USER"}
+             };
+
+     /*
+      * TODO complete or check this list
+      */
+     private static final String[][] STRING_FUNCTIONS = {
+             // Section C.2 JDBC 3.0 spec.
+//             {"ASCII", "'Yellow'"}, {"CHAR", "65"},
+//             {"CONCAT", "'hello'", "'there'"},
+//             {"DIFFERENCE", "'Pires'", "'Piers'"},
+//             {"INSERT", "'Bill Clinton'", "4", "'William'"},
+//             {"LCASE", "'Fernando Alonso'"}, {"LEFT", "'Bonjour'", "3"},
+//             {"LENGTH", "'four    '"}, {"LOCATE", "'jour'", "'Bonjour'"},
+             {"LTRIM", "'   left trim   '"}, 
+//               {"REPEAT", "'echo'", "3"},
+//             {"REPLACE", "'to be or not to be'", "'be'", "'England'"},
+//             {"RTRIM", "'  right trim   '"}, {"SOUNDEX", "'Derby'"},
+//             {"SPACE", "12"},
+//             {"SUBSTRING", "'Ruby the Rubicon Jeep'", "10", "7",},
+//             {"UCASE", "'Fernando Alonso'"}
+     };
+
+     /**
+      * Six combinations of valid identifiers with mixed case, to see how the
+      * various pattern matching and returned values handle them. This test only
+      * creates objects in these schemas.
+      */
+     private static final String[] IDS = {
+             "one_meta_test", "TWO_meta_test", "ThReE_meta_test",
+             "\"four_meta_test\"", "\"FIVE_meta_test\"", "\"sIx_meta_test\""};
+
+     /**
+      * All the builtin schemas.
+      */
+     private static final String[] BUILTIN_SCHEMAS = {
+             //TODO: Are there any other built in schemas?
+             
+     };
+
+     public static String getStoredIdentifier(String sqlIdentifier) {
+         if (sqlIdentifier.charAt(0) == '"')
+             return sqlIdentifier.substring(1, sqlIdentifier.length() - 1);
+         else
+             return sqlIdentifier.toUpperCase();
+     }
+
+     /**
+      * Test getSchemas() without modifying the database.
+      * 
+      * @throws SQLException
+      */
+     @TestTargetNew(
+             level = TestLevel.PARTIAL_COMPLETE,
+             notes = "Derby test for getSchema",
+             method = "getSchemas",
+             args = {}
+         )
+     public void testGetSchemasReadOnly() throws SQLException {
+
+         ResultSet rs = meta.getSchemas();
+         checkSchemas(rs, new String[0]);
+     }
+
+
+     /**
+      * Check the returned information from a getSchemas(). The passed in
+      * String[] expected is a list of the schemas expected to be present in the
+      * returned set. The returned set may contain additional schemas which will
+      * be ignored, thus this test can be used regardless of the database state.
+      * The builtin schemas are automatically checked and must not be part of the
+      * passed in list.
+      */
+     public static void checkSchemas(ResultSet rs, String[] userExpected)
+             throws SQLException {
+
+         // Add in the system schemas
+         String[] expected = new String[BUILTIN_SCHEMAS.length
+                 + userExpected.length];
+
+         System.arraycopy(BUILTIN_SCHEMAS, 0, expected, 0,
+                 BUILTIN_SCHEMAS.length);
+         System.arraycopy(userExpected, 0, expected, BUILTIN_SCHEMAS.length,
+                 userExpected.length);
+
+         // Remove any quotes from user schemas and upper case
+         // those without quotes.
+         for (int i = BUILTIN_SCHEMAS.length; i < expected.length; i++) {
+             expected[i] = getStoredIdentifier(expected[i]);
+         }
+
+         // output is ordered by TABLE_SCHEM
+         Arrays.sort(expected);
+
+         int nextMatch = 0;
+
+         while (rs.next()) {
+             String schema = rs.getString("TABLE_SCHEM");
+             assertNotNull(schema);
+
+             // Catalogs not supported
+//             assertNull(rs.getString("TABLE_CATALOG"));
+
+             if (nextMatch < expected.length) {
+                 if (expected[nextMatch].equals(schema)) nextMatch++;
+             }
+         }
+         rs.close();
+         assertEquals("Schemas missing ", expected.length, nextMatch);
+     }
+
+     private void assertMatchesPattern(String pattern, String result) {
+         if (!doesMatch(pattern, 0, result, 0)) {
+             fail("Bad pattern matching:" + pattern + " result:" + result);
+         }
+
+     }
+
+     /**
+      * See if a string matches the pattern as defined by DatabaseMetaData. By
+      * passing in non-zero values can check sub-sets of the pattern against the
+      * sub strings of the result. <BR>
+      * _ matches a single character <BR>
+      * % matches zero or more characters <BR>
+      * Other characters match themselves.
+      * 
+      * @param pattern
+      *            Pattern
+      * @param pp
+      *            Position in pattern to start the actual pattern from
+      * @param result
+      *            result string
+      * @param rp
+      *            position in result to starting checking
+      * @return true if a match is found
+      */
+     private boolean doesMatch(String pattern, int pp, String result, int rp) {
+         // Find a match
+         for (;;) {
+             if (pp == pattern.length() && rp == result.length()) return true;
+
+             // more characters to match in the result but
+             // no more pattern.
+             if (pp == pattern.length()) return false;
+
+             char pc = pattern.charAt(pp);
+             if (pc == '_') {
+                 // need to match a single character but
+                 // exhausted result, so no match.
+                 if (rp == result.length()) return false;
+
+                 pp++;
+                 rp++;
+             } else if (pc == '%') {
+                 // % at end, complete match regardless of
+                 // position of result since % matches zero or more.
+                 if (pp == pattern.length() - 1) {
+                     return true;
+                 }
+
+                 // Brut force, we have a pattern like %X
+                 // and we are say in the third character of
+                 // abCdefgX
+                 // then start a 'CdefgX' and look for a match,
+                 // then 'defgX' etc.
+                 for (int sp = rp; sp < result.length(); sp++) {
+                     if (doesMatch(pattern, pp + 1, result, sp)) {
+                         // Have a match for the pattern after the %
+                         // which means we have a match for the pattern
+                         // with the % since we can match 0 or mor characters
+                         // with %.
+                         return true;
+                     }
+                 }
+
+                 // Could not match the pattern after the %
+                 return false;
+             } else {
+                 // need to match a single character but
+                 // exhausted result, so no match.
+                 if (rp == result.length()) return false;
+
+                 // Single character, must match exactly.
+                 if (pc != result.charAt(rp)) {
+                     // Computer says no.
+                     return false;
+                 }
+                 pp++;
+                 rp++;
+             }
+
+         }
+
+     }
+
+
+     /**
+      * Check that the list of escaped functions provided by the driver is a
+      * strict subet of the specified set, the list does not contain duplicates,
+      * all the functions listed can be executed and that if a function is not in
+      * the list but is specified it cannot be executed.
+      */
+     private void escapedFunctions(String[][] specList, String metaDataList)
+             throws SQLException {
+         
+         boolean[] seenFunction = new boolean[specList.length];
+         
+         StringTokenizer st = new StringTokenizer(metaDataList, ",");
+         int counter = 0;
+         while (st.hasMoreTokens()) {
+             counter++;
+             String function = st.nextToken();
+
+             // find this function in the list
+             boolean isSpecFunction = false;
+             for (int f = 0; f < specList.length; f++) {
+                 String[] specDetails = specList[f];
+                 if (function.equals(specDetails[0])) {
+                     // Matched spec.
+                     if (seenFunction[f])
+                         fail("Function in list twice: " + function);
+                     seenFunction[f] = true;
+                     isSpecFunction = true;
+                     executeEscaped(specDetails);
+                     break;
+                 }
+             }
+
+             if (!isSpecFunction) {
+                 fail("Non-JDBC spec function in list: " + function);
+             }
+         }
+         
+         // Now see if any speced functions are not in the metadata list
+         assertSame("Function missing in metadata impl",specList.length, counter);
+         for (int f = 0; f < specList.length; f++) {
+             if (seenFunction[f]) continue;
+             String[] specDetails = specList[f];
+
+             // bug DERBY-723 CHAR maps to wrong function
+             if ("CHAR".equals(specDetails[0])) continue;
+             try {
+                 executeEscaped(specDetails);
+                 fail("function works but not declared in list: "
+                         + specDetails[0]);
+             } catch (SQLException e) {
+                 //ok
+             }
+         }
+     }
+     
+     /**
+      * Test we can execute a function listed as a supported
+      * JDBC escaped function. We don't care about the actual
+      * return value, that should be tested elsewhere in
+      * the specific test of a function.
+      */
+     private void executeEscaped(String[] specDetails)
+         throws SQLException
+     {
+         
+         String sql = "SELECT " + specDetails[0] + "(";
+         
+         for (int p = 0; p < specDetails.length - 1; p++)
+         {
+             if (p != 0)
+                 sql = sql + ", ";
+             
+             sql = sql + specDetails[p + 1];
+         }
+         
+         sql = sql + ") ;";       
+         
+         System.out.println("DatabaseMetaDataTest.executeEscaped() "+sql);
+         Statement st = conn.createStatement();
+         ResultSet rs = st.executeQuery(sql);
+         
+         assertNotNull("not supported function: "+sql,rs);
+         
+         rs.close();
+         st.close();
+     }
+     
+  //END APACHE-DERBY
+}
diff --git a/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java b/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java
new file mode 100755
index 0000000..6209548
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java
@@ -0,0 +1,268 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+@TestTargetClass(Statement.class)
+public class DeleteFunctionalityTest extends TestCase {
+
+    private static Connection conn = null;
+
+    private static Statement statement = null;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        DatabaseCreator.fillParentTable(conn);
+    }
+
+    protected void tearDown() throws Exception {
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKCASCADE_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.TEST_TABLE5);
+        super.tearDown();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                DeleteFunctionalityTest.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                statement.close();
+                conn.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    DatabaseMetaData meta = conn.getMetaData();
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.PARENT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_PARENT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKCASCADE_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKSTRICT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE5)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE5);
+                        }
+                    }
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.CREATE_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.DROP_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.DROP_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete1(). Deletes row with no
+     *        referencing ones and RESTRICT action
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Deletes row with no referencing ones and RESTRICT action",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    public void testDelete1() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
+                + " WHERE id = 3;");
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete2(). Attempts to delete row with
+     *        referencing ones and RESTRICT action - expecting SQLException
+     *  TODO foreign key functionality is not supported      
+     */
+/*    public void testDelete2() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        try {
+            statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
+                    + " WHERE id = 1;");
+            fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+        }
+    }
+*/
+    /**
+     * @tests DeleteFunctionalityTest#testDelete3(). Deletes all referencing
+     *        rows and then deletes referenced one
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Deletes all referencing rows and then deletes referenced one",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    public void testDelete3() throws SQLException {
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
+                + " WHERE name_id = 1;");
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
+                + " WHERE id = 1;");
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete4(). Deletes row with no
+     *        referencing ones and CASCADE action
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Deletes row with no referencing ones and CASCADE action",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    public void testDelete4() throws SQLException {
+        DatabaseCreator.fillFKCascadeTable(conn);
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
+                + " WHERE id = 3;");
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete5(). Attempts to delete row with
+     *        referencing ones and CASCADE action - expecting all referencing
+     *        rows will also be deleted
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Attempts to delete row with referencing ones and CASCADE action - expecting all referencing rows will also be deleted",
+            method = "execute",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Attempts to delete row with referencing ones and CASCADE action - expecting all referencing rows will also be deleted",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testDelete5() throws SQLException {
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
+                + " WHERE id = 1;");
+
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.FKCASCADE_TABLE + " WHERE name_id = 1;");
+        r.next();
+        assertEquals("Should be no rows", 0, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete6(). 
+     *  TODO Foreign key functionality is not supported      
+     */
+    @TestTargetNew(
+      level = TestLevel.PARTIAL_COMPLETE,
+      notes = "Deletes rows using subquery in WHERE clause with foreign keys. Foreign keys not supported.",
+      method = "execute",
+      args = {String.class}
+    )
+    @KnownFailure("not supported")
+    public void testDelete6() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
+                + " WHERE name_id = ANY (SELECT id FROM "
+                + DatabaseCreator.PARENT_TABLE + " WHERE id > 1)");
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.FKSTRICT_TABLE + " WHERE name_id = 1;");
+        r.next();
+        assertEquals("Should be 2 rows", 2, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests DeleteFunctionalityTest#testDelete7(). Deletes rows using
+     *        PreparedStatement
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Deletes rows using PreparedStatement",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void testDelete7() throws SQLException {
+        DatabaseCreator.fillTestTable5(conn);
+        PreparedStatement stat = conn.prepareStatement("DELETE FROM "
+                + DatabaseCreator.TEST_TABLE5 + " WHERE testID = ?");
+        stat.setInt(1, 1);
+        stat.execute();
+        stat.setInt(1, 2);
+        stat.execute();
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.TEST_TABLE5 + " WHERE testID < 3 ");
+        r.next();
+        assertEquals(0, r.getInt(1));
+        r.close();
+        stat.close();
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java b/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java
new file mode 100755
index 0000000..4d26751
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java
@@ -0,0 +1,321 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import tests.support.Support_SQL;
+import tests.support.DatabaseCreator;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+@TestTargetClass(Statement.class)
+public class InsertFunctionalityTest extends TestCase {
+
+    private static Connection conn = null;
+
+    private static Statement statement = null;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        Support_SQL.loadDriver();
+        conn = Support_SQL.getConnection();
+
+    }
+
+    protected void tearDown() throws Exception {
+        statement.execute("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE2);
+        statement.execute("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE1);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKCASCADE_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.TEST_TABLE5);
+        super.tearDown();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                InsertFunctionalityTest.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                statement.close();
+                conn.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    DatabaseMetaData meta = conn.getMetaData();
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.PARENT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_PARENT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKCASCADE_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKSTRICT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.SIMPLE_TABLE1)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_SIMPLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.SIMPLE_TABLE2)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_SIMPLE2);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE5)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE5);
+                        }
+                    }
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE2);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
+                    statement.execute(DatabaseCreator.CREATE_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.DROP_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.DROP_TABLE_SIMPLE2);
+                    statement.execute(DatabaseCreator.DROP_TABLE_SIMPLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert1(). Attempts to insert row into
+     *        table with integrity checking
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Attempts to insert row into table with integrity checking",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure(" SQLite.Exception: error in prepare/compile")
+    public void testInsert1() throws SQLException {
+        DatabaseCreator.fillParentTable(conn);
+        DatabaseCreator.fillFKStrictTable(conn);
+        DatabaseCreator.fillFKCascadeTable(conn);
+        statement.execute("INSERT INTO " + DatabaseCreator.FKSTRICT_TABLE
+                + " VALUES(4, 1, 'testInsert')");
+        statement.execute("INSERT INTO " + DatabaseCreator.FKCASCADE_TABLE
+                + " VALUES(4, 1, 'testInsert')");
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert2(). Attempts to insert row into
+     *        table with integrity checking when row has incorrect foreign key
+     *        value - expecting SQLException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Attempts to insert row into table with integrity checking when row has incorrect foreign key value - expecting SQLException",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure(" SQLite.Exception: error in prepare/compile")
+    public void testInsert2() throws SQLException {
+        DatabaseCreator.fillParentTable(conn);
+        DatabaseCreator.fillFKStrictTable(conn);
+        DatabaseCreator.fillFKCascadeTable(conn);
+        try {
+            statement.execute("INSERT INTO " + DatabaseCreator.FKSTRICT_TABLE
+                    + " VALUES(4, 4, 'testInsert')");
+           // TODO Foreign key functionality isn't supported 
+           // fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+        }
+        try {
+            statement.execute("INSERT INTO " + DatabaseCreator.FKCASCADE_TABLE
+                    + " VALUES(4, 4, 'testInsert')");
+           // TODO Foreign key functionality isn't supported 
+           // fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert3(). Tests INSERT ... SELECT
+     *        functionality
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Tests INSERT ... SELECT functionality",
+            method = "execute",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Tests INSERT ... SELECT functionality",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    @KnownFailure(" SQLite.Exception: error in prepare/compile")
+    public void testInsert3() throws SQLException {
+        DatabaseCreator.fillParentTable(conn);
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.execute("INSERT INTO " + DatabaseCreator.TEST_TABLE5
+                + " SELECT id AS testId, value AS testValue " + "FROM "
+                + DatabaseCreator.FKSTRICT_TABLE + " WHERE name_id = 1");
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.TEST_TABLE5);
+        r.next();
+        assertEquals("Should be 2 rows", 2, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert4(). Tests INSERT ... SELECT
+     *        with expressions in SELECT query
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Tests INSERT ... SELECT with expressions in SELECT query",
+            method = "execute",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Tests INSERT ... SELECT with expressions in SELECT query",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    @KnownFailure(" SQLite.Exception: error in prepare/compile")
+    public void testInsert4() throws SQLException {
+        DatabaseCreator.fillSimpleTable1(conn);
+        statement.execute("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE2
+                + " SELECT id, speed*10 AS speed, size-1 AS size FROM "
+                + DatabaseCreator.SIMPLE_TABLE1);
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.SIMPLE_TABLE2 + " AS a JOIN "
+                + DatabaseCreator.SIMPLE_TABLE1
+                + " AS b ON a.speed = 10*b.speed AND a.size = b.size-1");
+        r.next();
+        assertEquals("Should be 2 rows", 2, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert5(). Inserts multiple rows using
+     *        UNION ALL
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Inserts multiple rows using UNION ALL",
+            method = "execute",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Inserts multiple rows using UNION ALL",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testInsert5() throws SQLException {
+        statement.execute("INSERT INTO " + DatabaseCreator.TEST_TABLE5
+                + " SELECT 1 as testId, 2 as testValue "
+                + "UNION SELECT 2 as testId, 3 as testValue "
+                + "UNION SELECT 3 as testId, 4 as testValue");
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.TEST_TABLE5);
+        r.next();
+        assertEquals("Should be 3 rows", 3, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests InsertFunctionalityTest#testInsert6(). Tests INSERT with
+     *        PreparedStatement
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Tests INSERT with PreparedStatement",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure(" SQLite.Exception: error in prepare")
+    public void testInsertPrepared() throws SQLException {
+        PreparedStatement stat = conn.prepareStatement("INSERT INTO "
+                + DatabaseCreator.TEST_TABLE5 + " VALUES(?, ?)");
+        stat.setInt(1, 1);
+        stat.setString(2, "1");
+        stat.execute();
+        stat.setInt(1, 2);
+        stat.setString(2, "3");
+        stat.execute();
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.TEST_TABLE5
+                + " WHERE (testId = 1 AND testValue = '1') "
+                + "OR (testId = 2 AND testValue = '3')");
+        r.next();
+        assertEquals("Incorrect number of records", 2, r.getInt(1));
+        r.close();
+        stat.close();
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java b/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java
new file mode 100755
index 0000000..9675fce
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java
@@ -0,0 +1,473 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import tests.support.ThreadPool;
+
+@TestTargetClass(Statement.class)
+public class MultiThreadAccessTest extends TestCase {
+
+    private static Connection conn;
+
+    private static Statement statement;
+
+    private static final int numThreads = 10;
+
+    private static final int numOfRecords = 20;
+
+    private ThreadPool threadPool;
+
+    protected void setUp() throws Exception {
+        threadPool = new ThreadPool(numThreads);
+    }
+
+    protected void tearDown() throws Exception {
+        threadPool.join();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                MultiThreadAccessTest.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                conn.close();
+                statement.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    ResultSet userTab = conn.getMetaData().getTables(null,
+                            null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE2)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE2);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE4)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE4);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE3)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE3);
+                        }
+                    }
+
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE3);
+                    statement.execute(DatabaseCreator.CREATE_TABLE4);
+                    statement.execute(DatabaseCreator.CREATE_TABLE1);
+                    statement.execute(DatabaseCreator.CREATE_TABLE2);
+
+                    DatabaseCreator.fillTestTable1(conn, numOfRecords);
+                    DatabaseCreator.fillTestTable2(conn, numOfRecords);
+                    DatabaseCreator.fillTestTable4(conn, numOfRecords);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE2);
+                    statement.execute(DatabaseCreator.DROP_TABLE3);
+                    statement.execute(DatabaseCreator.DROP_TABLE4);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * A few threads execute select operation in the same time for one table in
+     * the database. Number of threads is defined by numThreads variable
+     * 
+     * @throws SQLException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Functionality test: A few threads execute select operation in the same time for one table in the database.",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_MultipleAccessToOneTable() throws SQLException {
+        for (int i = 0; i < numThreads; i++) {
+            threadPool.runTask(createTask1(i));
+        }
+    }
+
+    /**
+     * A few threads execute select operation in the same time for different
+     * tables in the database. Number of threads is defined by numThreads
+     * variable
+     * 
+     * @throws SQLException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Functionality test: A few threads execute select operation in the same time for different tables in the database",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_MultipleAccessToSeveralTables() throws SQLException {
+        threadPool.runTask(createTask1(1));
+        threadPool.runTask(createTask2(2));
+        threadPool.runTask(createTask3(3));
+    }
+
+    /**
+     * A few threads execute update, insert and delete operations in the same
+     * time for one table in the database. Number of threads is defined by
+     * numThreads variable
+     * 
+     * @throws SQLException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Functionality test: A few threads execute update, insert and delete operations in the same time for one table in the database",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_MultipleOperationsInSeveralTables() throws SQLException {
+        int id1 = numOfRecords - 1;
+        threadPool.runTask(createTask4(id1));
+
+        int id2 = numOfRecords + 1;
+        threadPool.runTask(createTask5(id2));
+
+        int oldID = 5;
+        int newID = 100;
+        threadPool.runTask(createTask6(oldID, newID));
+
+        threadPool.join();
+
+        Statement statement = conn.createStatement();
+        String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+                + " WHERE id=";
+
+        ResultSet result = statement.executeQuery(selectQuery + id1);
+        assertFalse("The record was not deleted", result.next());
+
+        result = statement.executeQuery(selectQuery + id2);
+        assertTrue("The record was not inserted", result.next());
+
+        assertEquals("Wrong value of field1", DatabaseCreator.defaultString
+                + id2, result.getString("field1"));
+//         TODO getBigDecimal is not supported
+        assertEquals("Wrong value of field2", Integer.valueOf(id2).intValue(), result
+                .getInt("field2"));
+        assertEquals("Wrong value of field3", Integer.valueOf(id2).intValue(), result
+                .getInt("field3"));
+        result.close();
+
+        result = statement.executeQuery(selectQuery + oldID);
+        assertFalse("The record was not deleted", result.next());
+        result.close();
+
+        result = statement.executeQuery(selectQuery + newID);
+        assertTrue("The record was not updated", result.next());
+
+        assertEquals("Wrong value of field1", DatabaseCreator.defaultString
+                + newID, result.getString("field1"));
+        // TODO getBigDecimal is not supported
+        assertEquals("Wrong value of field2", Integer.valueOf(newID).intValue(), result
+                .getInt("field2"));
+        assertEquals("Wrong value of field3", Integer.valueOf(newID).intValue(), result
+                .getInt("field3"));
+        result.close();
+    }
+
+    /**
+     * A few threads execute update operation in the same time for one tables in
+     * the database. Number of threads is defined by numThreads variable
+     * 
+     * @throws SQLException
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL,
+        notes = "Functional test: A few threads execute update operation in the same time for one tables in the database",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_MultipleUpdatesInOneTables() throws SQLException {
+        int id = 1;
+        String field = "field3";
+
+        String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1
+                + " WHERE id=" + id;
+        Statement statement = conn.createStatement();
+
+        ResultSet result = statement.executeQuery(selectQuery);
+        assertTrue("There is no records with id = " + id, result.next());
+        // TODO getBigDecimal is not supported
+//        assertEquals("Wrong value of field " + field, BigDecimal.valueOf(id),
+//                result.getBigDecimal(field));
+        result.close();
+
+        for (int i = 0; i < numThreads; i++) {
+            threadPool.runTask(createTask7(id, field));
+        }
+
+        threadPool.join();
+
+        double expectedVal = id + numThreads;
+        result = statement.executeQuery(selectQuery);
+        assertTrue("There is no records with id = " + id, result.next());
+        // TODO getBigDecimal is not supported -> 
+//        assertEquals("Wrong value of field " + field, expectedVal, result
+//                .getBigDecimal(field).doubleValue());
+        result.close();
+    }
+
+    /**
+     * This method creates a Runnable that executes select operation for the
+     * first table
+     * 
+     * @param taskID
+     * @return
+     */
+    private static Runnable createTask1(final int taskID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    ResultSet result = statement.executeQuery("SELECT * FROM "
+                            + DatabaseCreator.TEST_TABLE1);
+
+                    while (result.next()) {
+                        assertEquals("Wrong value of id ",
+                                DatabaseCreator.defaultString
+                                        + result.getInt("id"), result
+                                        .getString("field1"));
+                        assertEquals("Wrong value of field2 ", result.getInt("id"), result
+                                .getInt("field2"));
+                        assertEquals("Wrong value of field3 ",result.getInt("id"), result
+                                .getInt("field3"));
+                    }
+                    result.close();
+                } catch (Exception e) {
+                    System.err.println("Task 1 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that execute select operation for the
+     * second table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask2(final int taskID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    ResultSet result = statement.executeQuery("SELECT * FROM "
+                            + DatabaseCreator.TEST_TABLE2);
+
+                    while (result.next()) {
+                        while (result.next()) {
+                            int id = result.getInt("finteger");
+                            assertEquals("Wrong value of ftext",
+                                    DatabaseCreator.defaultString + id, result
+                                            .getString("ftext"));
+                            assertEquals("Wrong value of fcharacter",
+                                    DatabaseCreator.defaultCharacter + id,
+                                    result.getString("fcharacter"));
+                            assertEquals("Wrong value of fdecimal",
+                                    DatabaseCreator.defaultDouble + id, result
+                                            .getDouble("fdecimal"));
+                            assertEquals("Wrong value of fnumeric",
+                                    DatabaseCreator.defaultDouble + id, result
+                                            .getDouble("fnumeric"));
+                            assertEquals("Wrong value of fsmallint", result
+                                    .getInt("finteger"), result
+                                    .getShort("fsmallint"));
+                            assertEquals("Wrong value of ffloat",
+                                    (float) DatabaseCreator.defaultDouble + id,
+                                    result.getFloat("ffloat"));
+                            assertEquals("Wrong value of freal",
+                                    (float) DatabaseCreator.defaultDouble + id,
+                                    result.getFloat("freal"));
+                            assertEquals("Wrong value of fdouble",
+                                    DatabaseCreator.defaultDouble + id, result
+                                            .getDouble("fdouble"));
+                        }
+                    }
+                    result.close();
+                } catch (Exception e) {
+                    System.err.println("Task2 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that execute select operation for the
+     * third table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask3(final int taskID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    ResultSet result = statement.executeQuery("SELECT * FROM "
+                            + DatabaseCreator.TEST_TABLE4);
+
+                    while (result.next()) {
+                        assertEquals("Wrong value of field1",
+                                DatabaseCreator.defaultString
+                                        + result.getInt("fk"), result
+                                        .getString("field1"));
+                    }
+                    result.close();
+                } catch (Exception e) {
+                    System.err.println("Task 3 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that executes delete operation for the
+     * first table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask4(final int id) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    statement.execute("DELETE FROM "
+                            + DatabaseCreator.TEST_TABLE1 + " WHERE id=" + id);
+                } catch (Exception e) {
+                    System.err.println("Task 4 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that executes insert operation for the
+     * first table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask5(final int id) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    String value = DatabaseCreator.defaultString + id;
+
+                    String insertQuery = "INSERT INTO "
+                            + DatabaseCreator.TEST_TABLE1
+                            + " (id, field1, field2, field3) VALUES(" + id
+                            + ", '" + value + "', " + id + ", " + id + ")";
+                    statement.execute(insertQuery);
+                } catch (Exception e) {
+                    System.err.println("Task 5 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that executes update operation for the one
+     * record of the first table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask6(final int oldID, final int newID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    String value = DatabaseCreator.defaultString + newID;
+                    String updateQuery = "UPDATE "
+                            + DatabaseCreator.TEST_TABLE1 + " SET id=" + newID
+                            + ", field1='" + value + "', field2=" + newID
+                            + ", field3=" + newID + " WHERE id=" + oldID;
+                    statement.execute(updateQuery);
+                } catch (Exception e) {
+                    System.err.println("Task 6 "+e.getMessage());
+                }
+            }
+        };
+    }
+
+    /**
+     * This method creates a Runnable that executes update operation for the one
+     * field of one record with identifier id in the first table
+     * 
+     * @param taskID
+     */
+    private static Runnable createTask7(final int id, final String field) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Statement statement = conn.createStatement();
+                    String updateQuery = "UPDATE "
+                            + DatabaseCreator.TEST_TABLE1 + " SET " + field
+                            + "= " + field + "+ 1 WHERE id=" + id;
+                    statement.execute(updateQuery);
+                } catch (Exception e) {
+                    System.err.println("Task 7 "+e.getMessage());
+                }
+            }
+        };
+    }
+}
\ No newline at end of file
diff --git a/sql/src/test/java/tests/java/sql/QueryTimeoutTest.java b/sql/src/test/java/tests/java/sql/QueryTimeoutTest.java
new file mode 100644
index 0000000..c6452b5
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/QueryTimeoutTest.java
@@ -0,0 +1,766 @@
+/*
+ * 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.java.sql;
+
+import SQLite.Database;
+import SQLite.Function;
+import SQLite.FunctionContext;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+import tests.support.Support_SQL;
+
+import java.sql.CallableStatement;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashSet;
+
+
+/**
+ * Functional test for the Statement.setQueryTimeout() method. Adopted from
+ * Apache Derby project (Apache License 2.0).
+ * 
+ * TODO Test requires transaction isolation to be supported. => Ticket 69
+ * 
+ * This test consists of four parts: 1. Executes a SELECT
+ * query in 4 different threads concurrently. The query calls a user-defined,
+ * server-side function which delays the execution, so that it takes several
+ * seconds even though the data volume is really low. The fetch operations take
+ * longer time than the timeout value set. Hence, this part tests getting
+ * timeouts from calls to ResultSet.next(). Two connections are used, two
+ * threads execute their statement in the context of one connection, the other
+ * two threads in the context of the other connection. Of the 4 threads, only
+ * one executes its statement with a timeout value. This way, the test ensures
+ * that the correct statement is affected by setQueryTimeout(), regardless of
+ * what connection/transaction it and other statements are executed in the
+ * context of. 
+ * 
+ * 2. Executes an INSERT query in multiple threads. This part tests
+ * getting timeouts from calls to Statement.execute(). Each thread executes the
+ * query in the context of a separate connection. There is no point in executing
+ * multiple statements on the same connection; since only one statement per
+ * connection executes at a time, there will be no interleaving of execution
+ * between them (contrary to the first part of this test, where calls to
+ * ResultSet.next() may be interleaved between the different threads). Half of
+ * the threads execute their statement with a timeout value set, this is to
+ * verify that the correct statements are affected by the timeout, while the
+ * other statements execute to completion. 
+ * 3. Sets an invalid (negative)
+ * timeout. Verifies that the correct exception is thrown. 
+ * 4. Tests that the query timeout value is not forgotten after the execution of a statement.
+ */
+@TestTargetClass(Statement.class)
+public class QueryTimeoutTest extends TestCase {
+
+    private static Statement statement;
+
+    private static final int TIMEOUT = 1; // In seconds
+    private static final int CONNECTIONS = 100;
+
+    private static Connection[] connections = new Connection[CONNECTIONS];
+
+    private static void printSQLException(SQLException e) {
+        while (e != null) {
+            e.printStackTrace();
+            e = e.getNextException();
+        }
+    }
+
+    /**
+     * This Exception class is used for getting fail-fast behaviour in this
+     * test. There is no point in wasting cycles running a test to the end when
+     * we know that it has failed. In order to enable chaining of exceptions in
+     * J2ME, this class defines its own "cause", duplicating existing
+     * functionality in J2SE.
+     */
+    private static class TestFailedException extends Exception {
+        private Throwable cause;
+
+        public TestFailedException(Throwable t) {
+            super();
+            cause = t;
+        }
+
+        public TestFailedException(String message) {
+            super(message);
+            cause = null;
+        }
+
+        public TestFailedException(String message, Throwable t) {
+            super(message);
+            cause = t;
+        }
+
+        public String toString() {
+            if (cause != null) {
+                return super.toString() + ": " + cause.toString();
+            } else {
+                return super.toString();
+            }
+        }
+
+        public void printStackTrace() {
+            super.printStackTrace();
+            if (cause != null) {
+                if (cause instanceof SQLException) {
+                    QueryTimeoutTest.printSQLException((SQLException) cause);
+                } else {
+                    cause.printStackTrace();
+                }
+            }
+        }
+    }
+
+    /**
+     * Used for executing the SQL statements for setting up this test (the
+     * preparation phase). The queries testing setQueryTimeout() are run by the
+     * StatementExecutor class.
+     */
+    private static void exec(Connection connection, String queryString,
+            Collection ignoreExceptions) throws TestFailedException {
+        Statement statement = null;
+        try {
+            statement = connection.createStatement();
+            System.out.println(" Executing "+queryString);
+            statement.execute(queryString);
+        } catch (SQLException e) {
+            String sqlState = e.getSQLState();
+            if (!ignoreExceptions.contains(sqlState)) {
+                throw new TestFailedException(e); // See finally block below
+            }
+        } finally {
+            if (statement != null) {
+                try {
+                    statement.close();
+                } catch (SQLException ee) {
+                    // This will discard an exception possibly thrown above :-(
+                    // But we don't worry too much about this, since:
+                    // 1. This is just a test
+                    // 2. We don't expect close() to throw
+                    // 3. If it does, this will be inspected by a developer
+                    throw new TestFailedException(ee);
+                }
+            }
+        }
+    }
+
+    // Convenience method
+    private static void exec(Connection connection, String queryString)
+            throws TestFailedException {
+        exec(connection, queryString, Collections.EMPTY_SET);
+    }
+
+    private static void dropTables(Connection conn, String tablePrefix)
+            throws TestFailedException {
+        Collection ignore = new HashSet();
+        //ignore.add("42Y55");
+
+        exec(conn, "drop table if exists " + tablePrefix + "_orig;", ignore);
+        exec(conn, "drop table if exists " + tablePrefix + "_copy;", ignore);
+    }
+
+    private static void prepareTables(Connection conn, String tablePrefix)
+            throws TestFailedException {
+        System.out.println("Initializing tables with prefix " + tablePrefix);
+
+        dropTables(conn, tablePrefix);
+
+        exec(conn, "create table " + tablePrefix + "_orig (a int)");
+
+        exec(conn, "create table " + tablePrefix + "_copy (a int)");
+        
+        for (int i = 0; i < 7; i++) {
+        exec(conn, "insert into " + tablePrefix + "_orig"
+                + " values ("+i+");");
+        }
+    }
+
+    private static String getFetchQuery(String tablePrefix) {
+        /**
+         * The reason for using the mod function here is to force at least one
+         * invocation of ResultSet.next() to read more than one row from the
+         * table before returning. This is necessary since timeout is checked
+         * only when reading rows from base tables, and when the first row is
+         * read, the query still has not exceeded the timeout.
+         */
+        return "select a from " + tablePrefix
+                + "_orig where mod(DELAY(1,a),3)=0";
+    }
+
+    private static String getExecQuery(String tablePrefix) {
+        return "insert into " + tablePrefix + "_copy select a from "
+                + tablePrefix + "_orig where DELAY(1,1)=1";
+    }
+
+    private static class StatementExecutor extends Thread {
+        private PreparedStatement statement;
+        private boolean doFetch;
+        private int timeout;
+        private SQLException sqlException;
+        private String name;
+        private long highestRunTime;
+
+        public StatementExecutor(PreparedStatement statement, boolean doFetch,
+                int timeout) {
+            this.statement = statement;
+            this.doFetch = doFetch;
+            this.timeout = timeout;
+            highestRunTime = 0;
+            sqlException = null;
+            if (timeout > 0) {
+                try {
+                    statement.setQueryTimeout(timeout);
+                } catch (SQLException e) {
+                    sqlException = e;
+                }
+            }
+        }
+
+        private void setHighestRunTime(long runTime) {
+            synchronized (this) {
+                highestRunTime = runTime;
+            }
+        }
+
+        public long getHighestRunTime() {
+            synchronized (this) {
+                return highestRunTime;
+            }
+        }
+
+        private boolean fetchRow(ResultSet resultSet) throws SQLException {
+            long startTime = System.currentTimeMillis();
+            boolean hasNext = resultSet.next();
+            long endTime = System.currentTimeMillis();
+            long runTime = endTime - startTime;
+            if (runTime > highestRunTime) setHighestRunTime(runTime);
+            return hasNext;
+        }
+
+        public void run() {
+            if (sqlException != null) return;
+
+            ResultSet resultSet = null;
+
+            try {
+                if (doFetch) {
+                    long startTime = System.currentTimeMillis();
+                    resultSet = statement.executeQuery();
+                    long endTime = System.currentTimeMillis();
+                    setHighestRunTime(endTime - startTime);
+                    while (fetchRow(resultSet)) {
+                        yield();
+                    }
+                } else {
+                    long startTime = System.currentTimeMillis();
+                    statement.execute();
+                    long endTime = System.currentTimeMillis();
+                    setHighestRunTime(endTime - startTime);
+                }
+            } catch (SQLException e) {
+                synchronized (this) {
+                    sqlException = e;
+                }
+            } finally {
+                if (resultSet != null) {
+                    try {
+                        resultSet.close();
+                    } catch (SQLException ex) {
+                        if (sqlException != null) {
+                            System.err.println("Discarding previous exception");
+                            sqlException.printStackTrace();
+                        }
+                        sqlException = ex;
+                    }
+                }
+            }
+        }
+
+        public SQLException getSQLException() {
+            synchronized (this) {
+                return sqlException;
+            }
+        }
+    }
+
+    /**
+     * This method compares a thrown SQLException's SQLState value to an
+     * expected SQLState. If they do not match, a TestFailedException is thrown
+     * with the given message string.
+     */
+    private static void expectException(String expectSqlState,
+            SQLException sqlException, String failMsg)
+            throws TestFailedException {
+        if (sqlException == null) {
+            throw new TestFailedException(failMsg);
+        } else {
+            String sqlState = sqlException.getSQLState();
+            if (!expectSqlState.equals(sqlState)) {
+                throw new TestFailedException(sqlException);
+            }
+        }
+    }
+
+    // A convenience method which wraps a SQLException
+    private static PreparedStatement prepare(Connection conn, String query)
+            throws TestFailedException {
+        try {
+            return conn.prepareStatement(query);
+        } catch (SQLException e) {
+            throw new TestFailedException(e);
+        }
+    }
+
+    /**
+     * Part 1 of this test.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Testing timeout with fetch operations",
+        method = "setQueryTimeout",
+        args = {int.class}
+    )
+    public static void testTimeoutWithFetch() throws TestFailedException {
+        System.out.println("Testing timeout with fetch operations");
+
+        Connection conn1 = connections[0];
+        Connection conn2 = connections[1];
+
+        try {
+            conn1.setAutoCommit(false);
+            conn2.setAutoCommit(false);
+        } catch (SQLException e) {
+            throw new TestFailedException("Unexpected Exception", e);
+        }
+
+        // The idea with these 4 statements is as follows:
+        // A - should time out
+        // B - different stmt on the same connection; should NOT time out
+        // C - different stmt on different connection; should NOT time out
+        // D - here just to create equal contention on conn1 and conn2
+
+        PreparedStatement statementA = prepare(conn1, getFetchQuery("t"));
+        PreparedStatement statementB = prepare(conn1, getFetchQuery("t"));
+        PreparedStatement statementC = prepare(conn2, getFetchQuery("t"));
+        PreparedStatement statementD = prepare(conn2, getFetchQuery("t"));
+
+        StatementExecutor[] statementExecutor = new StatementExecutor[4];
+        statementExecutor[0] = new StatementExecutor(statementA, true, TIMEOUT);
+        statementExecutor[1] = new StatementExecutor(statementB, true, 0);
+        statementExecutor[2] = new StatementExecutor(statementC, true, 0);
+        statementExecutor[3] = new StatementExecutor(statementD, true, 0);
+
+        for (int i = 3; i >= 0; --i) {
+            statementExecutor[i].start();
+        }
+
+        for (int i = 0; i < 4; ++i) {
+            try {
+                statementExecutor[i].join();
+            } catch (InterruptedException e) {
+                throw new TestFailedException("Should never happen", e);
+            }
+        }
+
+        /**
+         * Actually, there is no guarantee that setting a query timeout for a
+         * statement will actually cause a timeout, even if execution of the
+         * statement takes longer than the specified timeout. However, these
+         * queries execute significantly longer than the specified query
+         * timeout. Also, the cancellation mechanism implemented should be quite
+         * responsive. In sum, we expect the statement to always time out. If it
+         * does not time out, however, we print the highest execution time for
+         * the query, as an assistance in determining why it failed. Compare the
+         * number to the TIMEOUT constant in this class (note that the TIMEOUT
+         * constant is in seconds, while the execution time is in milliseconds).
+         */
+        expectException("XCL52", statementExecutor[0].getSQLException(),
+                "fetch did not time out. Highest execution time: "
+                        + statementExecutor[0].getHighestRunTime() + " ms");
+
+        System.out.println("Statement 0 timed out");
+
+        for (int i = 1; i < 4; ++i) {
+            SQLException sqlException = statementExecutor[i].getSQLException();
+            if (sqlException != null) {
+                throw new TestFailedException("Unexpected exception in " + i,
+                        sqlException);
+            }
+            System.out.println("Statement " + i + " completed");
+        }
+
+        try {
+            statementA.close();
+            statementB.close();
+            statementC.close();
+            statementD.close();
+            conn1.commit();
+            conn2.commit();
+        } catch (SQLException e) {
+            throw new TestFailedException(e);
+        }
+    }
+
+    /**
+     * 
+     * @test {@link java.sql.Statement#setQueryTimeout(int) }
+     * 
+     * Part two of this test.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "test timeout with st.exec()",
+        method = "setQueryTimeout",
+        args = {int.class}
+    )
+    public static void testTimeoutWithExec()
+            throws TestFailedException {
+        System.out.println("Testing timeout with an execute operation");
+
+        for (int i = 0; i < connections.length; ++i) {
+            try {
+                connections[i].setAutoCommit(true);
+            } catch (SQLException e) {
+                throw new TestFailedException("Unexpected Exception", e);
+            }
+        }
+
+        PreparedStatement statements[] = new PreparedStatement[connections.length];
+        for (int i = 0; i < statements.length; ++i) {
+            statements[i] = prepare(connections[i], getExecQuery("t"));
+        }
+
+        StatementExecutor[] executors = new StatementExecutor[statements.length];
+        for (int i = 0; i < executors.length; ++i) {
+            int timeout = (i % 2 == 0) ? TIMEOUT : 0;
+            executors[i] = new StatementExecutor(statements[i], false, timeout);
+        }
+
+        for (int i = 0; i < executors.length; ++i) {
+            executors[i].start();
+        }
+
+        for (int i = 0; i < executors.length; ++i) {
+            try {
+                executors[i].join();
+            } catch (InterruptedException e) {
+                throw new TestFailedException("Should never happen", e);
+            }
+        }
+
+        /**
+         * Actually, there is no guarantee that setting a query timeout for a
+         * statement will actually cause a timeout, even if execution of the
+         * statement takes longer than the specified timeout. However, these
+         * queries execute significantly longer than the specified query
+         * timeout. Also, the cancellation mechanism implemented should be quite
+         * responsive. In sum, we expect the statement to always time out. If it
+         * does not time out, however, we print the highest execution time for
+         * the query, as an assistance in determining why it failed. Compare the
+         * number to the TIMEOUT constant in this class (note that the TIMEOUT
+         * constant is in seconds, while the execution time is in milliseconds).
+         */
+        for (int i = 0; i < executors.length; ++i) {
+            int timeout = (i % 2 == 0) ? TIMEOUT : 0;
+            if (timeout > 0) {
+                expectException("XCL52", executors[i].getSQLException(),
+                        "exec did not time out. Execution time: "
+                                + executors[i].getHighestRunTime() + " ms");
+            } else {
+                SQLException sqlException = executors[i].getSQLException();
+                if (sqlException != null) {
+                    throw new TestFailedException(sqlException);
+                }
+            }
+        }
+
+        System.out
+                .println("Statements that should time out timed out, and statements that should complete completed");
+
+        for (int i = 0; i < statements.length; ++i) {
+            try {
+                statements[i].close();
+            } catch (SQLException e) {
+                throw new TestFailedException(e);
+            }
+        }
+    }
+
+    
+    /**
+     * 
+     * @test {@link java.sql.Statement#setQueryTimeout(int) }
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Testing setting a negative timeout value",
+        method = "setQueryTimeout",
+        args = {int.class}
+    )
+    public static void testInvalidTimeoutValue(Connection conn)
+            throws TestFailedException {
+        
+        try {
+            conn.setAutoCommit(true);
+        } catch (SQLException e) {
+            throw new TestFailedException("Unexpected Exception", e);
+        }
+
+        // Create statement
+        PreparedStatement stmt = null;
+        try {
+            stmt = conn.prepareStatement("select * from sys.systables");
+        } catch (SQLException e) {
+            throw new TestFailedException("Unexpected Exception", e);
+        }
+
+        // Set (invalid) timeout value - expect exception
+        try {
+            stmt.setQueryTimeout(-1);
+        } catch (SQLException e) {
+            expectException("XJ074", e,
+                    "negative timeout value should give exception");
+        }
+
+        System.out
+                .println("Negative timeout value caused exception, as expected");
+
+        // Execute the statement and fetch result
+        ResultSet rs = null;
+        try {
+            rs = stmt.executeQuery();
+            System.out.println("Execute returned a ResultSet");
+            rs.close();
+        } catch (SQLException e) {
+            throw new TestFailedException("Unexpected Exception", e);
+        } finally {
+            try {
+                stmt.close();
+            } catch (SQLException e) {
+                // This will discard an exception possibly thrown above :-(
+                // But we don't worry too much about this, since:
+                // 1. This is just a test
+                // 2. We don't expect close() to throw
+                // 3. If it does, this will be inspected by a developer
+                throw new TestFailedException("close should not throw", e);
+            }
+        }
+    }
+    
+    /**
+     * 
+     * @test {@link java.sql.Statement#setQueryTimeout(int) }
+     * 
+     * Part two of this test.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "timeout with executeUpdate call",
+        method = "setQueryTimeout",
+        args = {int.class}
+    )
+    public static void testTimeoutWithExecuteUpdate()
+            throws TestFailedException {
+        System.out.println("Testing timeout with executeUpdate call.");
+        try {
+            Statement stmt = connections[0].createStatement();
+            stmt.setQueryTimeout(TIMEOUT);
+            stmt.executeUpdate(getExecQuery("t"));
+        } catch (SQLException sqle) {
+            expectException("XCL52", sqle, "Should have timed out.");
+        }
+    }
+
+    /** Test for DERBY-1692. */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Testing that Statement considers timeout.",
+            method = "setQueryTimeout",
+            args = {int.class}
+        )
+    public static void testRememberTimeoutValue()
+            throws TestFailedException {
+        String sql = getFetchQuery("t");
+        try {
+            Statement stmt = connections[0].createStatement();
+            statementRemembersTimeout(stmt);
+            PreparedStatement ps = connections[0].prepareStatement(sql);
+            statementRemembersTimeout(ps);
+            CallableStatement cs = connections[0].prepareCall(sql);
+            statementRemembersTimeout(cs);
+        } catch (SQLException sqle) {
+            throw new TestFailedException("Unexpected Exception", sqle);
+        }
+    }
+
+    public static void statementRemembersTimeout(Statement stmt)
+            throws SQLException, TestFailedException {
+        System.out.println("Testing that Statement remembers timeout.");
+        stmt.setQueryTimeout(1);
+        for (int i = 0; i < 3; i++) {
+            try {
+                ResultSet rs = stmt.executeQuery(getFetchQuery("t"));
+                while (rs.next()) {
+                    // do nothing
+                }
+                throw new TestFailedException("Should have timed out.");
+            } catch (SQLException sqle) {
+                expectException("XCL52", sqle, "Should have timed out.");
+            }
+        }
+        stmt.close();
+    }
+
+    private static void statementRemembersTimeout(PreparedStatement ps)
+            throws SQLException, TestFailedException {
+        String name = (ps instanceof CallableStatement) ? "CallableStatement"
+                : "PreparedStatement";
+        System.out.println("Testing that " + name + " remembers timeout.");
+        ps.setQueryTimeout(1);
+        for (int i = 0; i < 3; i++) {
+            try {
+                ResultSet rs = ps.executeQuery();
+                while (rs.next()) {
+                    // do nothing
+                }
+                throw new TestFailedException("Should have timed out.");
+            } catch (SQLException sqle) {
+                expectException("XCL52", sqle, "Should have timed out.");
+            }
+        }
+        ps.close();
+    }
+
+    /**
+     * A function 
+     * arg0 : int seconds
+     *
+     */
+    static class Delay implements SQLite.Function {
+
+        public void function(FunctionContext fc, String[] args) {
+            int seconds = new Integer(args[0]).intValue();
+            int value = new Integer(args[1]).intValue();
+            try {
+                Thread.sleep(seconds * 1000);
+            } catch (InterruptedException e) {
+                // Ignore
+            }
+            fc.set_result(value);
+
+        }
+
+        public void last_step(FunctionContext fc) {
+            // TODO Auto-generated method stub
+
+        }
+
+        public void step(FunctionContext fc, String[] args) {
+            // TODO Auto-generated method stub
+
+        }
+
+    }
+
+    /**
+     * The actual main bulk of this test. Sets up the environment, prepares
+     * tables, runs the tests, and shuts down.
+     */
+    public static Test suite() {
+        
+        TestSetup setup = new TestSetup( new TestSuite (QueryTimeoutTest.class)) {
+            public void setUp() {
+                
+                // Establish connections
+                Support_SQL.loadDriver();
+                try {
+
+                    for (int i = 0; i < connections.length; ++i) {
+                        connections[i] = Support_SQL.getConnection();
+                    }
+
+                    for (int i = 0; i < connections.length; ++i) {
+                        connections[i]
+                                .setTransactionIsolation(Connection.TRANSACTION_READ_UNCOMMITTED);
+                    }
+                    
+                    // setup Delay function
+                    prepare();
+
+                } catch (Throwable e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+
+                System.out.println("Connections set up");
+                
+            }
+
+            public void tearDown() {
+                for (int i = connections.length - 1; i >= 0; --i) {
+                    if (connections[i] != null) {
+                        try {
+                            connections[i].close();
+                        } catch (SQLException ex) {
+                            printSQLException(ex);
+                        }
+                    }
+                }
+                System.out.println("Closed connections");
+            }
+            
+            public void prepare() throws TestFailedException {
+                System.out.println("Preparing for testing queries with timeout");
+                Database db = new Database();
+
+                Connection conn = connections[0];
+
+
+                try {
+                    db.open(Support_SQL.getFilename(), 1);
+                    conn.setAutoCommit(true);
+                } catch (Exception e) {
+                    throw new TestFailedException("Unexpected Exception", e);
+                }
+
+                Function delayFc = new Delay();
+                db.create_function("DELAY", 2, delayFc);
+
+                prepareTables(conn, "t");
+            }
+        };
+       
+        TestSuite ts = new TestSuite();
+        ts.addTestSuite(QueryTimeoutTest.class);
+
+        return setup;
+    }
+
+}
diff --git a/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java b/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java
new file mode 100755
index 0000000..5c8f189
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java
@@ -0,0 +1,632 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.io.CharArrayReader;
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Time;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.HashSet;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+@TestTargetClass(Statement.class)
+public class SelectFunctionalityTest extends TestCase {
+
+    private static Connection conn;
+
+    private static Statement statement;
+
+    private static Date date;
+
+    private static Time time;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+    }
+
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                SelectFunctionalityTest.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                conn.close();
+                statement.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    ResultSet userTab = conn.getMetaData().getTables(null,
+                            null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE2)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE2);
+                        } else if (tableName
+                                .equals(DatabaseCreator.SALESPEOPLE_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_SALESPEOPLE);
+                        } else if (tableName
+                                .equals(DatabaseCreator.CUSTOMERS_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_CUSTOMERS);
+                        } else if (tableName
+                                .equals(DatabaseCreator.ORDERS_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_ORDERS);
+                        }
+                    }
+                    userTab.close();
+
+                    statement.execute(DatabaseCreator.CREATE_TABLE2);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_SALESPEOPLE);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_CUSTOMERS);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_ORDERS);
+
+                    long currentTime = Calendar.getInstance().getTimeInMillis();
+                    date = new Date(currentTime);
+                    time = new Time(currentTime);
+
+                    DatabaseCreator.fillTestTable2(conn, 1, 5, currentTime);
+                    DatabaseCreator.fillCustomersTable(conn);
+                    DatabaseCreator.fillOrdersTable(conn);
+                    DatabaseCreator.fillSalesPeopleTable(conn);
+
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE2);
+                    statement.execute(DatabaseCreator.DROP_TABLE_SALESPEOPLE);
+                    statement.execute(DatabaseCreator.DROP_TABLE_CUSTOMERS);
+                    statement.execute(DatabaseCreator.DROP_TABLE_ORDERS);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectSimple(). Selects all records
+     *        from the table
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects all records from the table",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectSimple() throws SQLException {
+        String sql = "SELECT * FROM " + DatabaseCreator.TEST_TABLE2;
+        ResultSet result = statement.executeQuery(sql);
+        int counter = 0;
+
+        while (result.next()) {
+            int id = result.getInt("finteger");
+            assertEquals("expected value doesn't equal actual",
+                    DatabaseCreator.defaultString + id, result
+                            .getString("ftext"));
+            assertEquals("expected value doesn't equal actual",
+                    DatabaseCreator.defaultCharacter + id, result
+                            .getString("fcharacter"));
+            
+            // TODO getBigDecimal is not supported
+//            assertEquals("expected value doesn't equal actual", BigDecimal
+//                    .valueOf(id + 0.1), result.getBigDecimal("fdecimal"));
+//            assertEquals("expected value doesn't equal actual", BigDecimal
+//                    .valueOf(id + 0.1), result.getBigDecimal("fnumeric"));
+//            assertEquals("expected value doesn't equal actual", id, result
+//                    .getInt("fsmallint"));
+            assertEquals("expected value doesn't equal actual", BigDecimal
+                    .valueOf(id + 0.1).floatValue(), result.getFloat("ffloat"));
+            assertEquals("expected value doesn't equal actual", BigDecimal
+                    .valueOf(id + 0.1).doubleValue(), result.getDouble("freal"));
+            assertEquals("expected value doesn't equal actual", BigDecimal
+                    .valueOf(id + 0.1).doubleValue(), result
+                    .getDouble("fdouble"));
+            assertEquals("expected value doesn't equal actual",
+                    date.toString(), result.getDate("fdate").toString());
+            assertEquals("expected value doesn't equal actual",
+                    time.toString(), result.getTime("ftime").toString());
+            counter++;
+        }
+         
+        assertEquals("number of rows in ResultSet is wrong", 5, counter);
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectPrepared(). Selects all records
+     *        from the table using parametric query
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects all records from the table using parametric query",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectPrepared() throws SQLException {
+        String sql = "SELECT finteger, ftext, fcharacter, fdecimal, fnumeric,"
+                + " fsmallint, ffloat, freal, fdouble, fdate, ftime" + " FROM "
+                + DatabaseCreator.TEST_TABLE2
+                + " WHERE finteger = ? AND ftext = ? AND fcharacter = ? AND"
+                + " fdecimal = ? AND fnumeric = ? AND fsmallint = ? AND"
+                + " freal = ? AND fdouble = ? AND fdate = ?" + " AND ftime = ?";
+        PreparedStatement prepStatement = conn.prepareStatement(sql);
+
+        CharArrayReader reader = new CharArrayReader(new String(
+                DatabaseCreator.defaultCharacter + "1").toCharArray());
+        prepStatement.setInt(1, 1);
+        prepStatement.setString(2, DatabaseCreator.defaultString + "1");
+//      TODO setCharacterStream and setBigDecimal are not supported
+//        prepStatement.setCharacterStream(3, reader, 4);
+//        prepStatement.setBigDecimal(4, BigDecimal.valueOf(1.1));
+//        prepStatement.setBigDecimal(5, BigDecimal.valueOf(1.1));
+        prepStatement.setInt(6, 1);
+        prepStatement.setDouble(7, 1.1);
+        prepStatement.setDouble(8, 1.1);
+        prepStatement.setDate(9, date);
+        prepStatement.setTime(10, time);
+
+        int counter = 0;
+        ResultSet result = prepStatement.executeQuery();
+        while (result.next()) {
+            int id = result.getInt("finteger");
+            assertEquals("expected value doesn't equal actual",
+                    DatabaseCreator.defaultString + id, result
+                            .getString("ftext"));
+            assertEquals("expected value doesn't equal actual",
+                    DatabaseCreator.defaultCharacter + id, result
+                            .getString("fcharacter"));
+//            TODO getBigDecimal is not supported              
+//            assertEquals("expected value doesn't equal actual", BigDecimal
+//                    .valueOf(1.1), result.getBigDecimal("fdecimal"));
+//            assertEquals("expected value doesn't equal actual", BigDecimal
+//                    .valueOf(1.1), result.getBigDecimal("fnumeric"));
+            assertEquals("expected value doesn't equal actual", id, result
+                    .getInt("fsmallint"));
+            assertEquals("expected value doesn't equal actual",
+                    (float) (id + 0.1), result.getFloat("ffloat"));
+            assertEquals("expected value doesn't equal actual",
+                    (double) (id + 0.1), result.getDouble("freal"));
+            assertEquals("expected value doesn't equal actual",
+                    (double) (id + 0.1), result.getDouble("fdouble"));
+            assertEquals("expected value doesn't equal actual",
+                    date.toString(), result.getDate("fdate").toString());
+            assertEquals("expected value doesn't equal actual",
+                    time.toString(), result.getTime("ftime").toString());
+            counter++;
+        }
+//       TODO query wasn't executed due to "not supported" methods         
+//        assertEquals("number of rows in ResultSet is wrong", 1, counter);
+        prepStatement.close();
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SubSelect(). Selects records from the
+     *        table using subselect
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from the table using subselect",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SubSelect() throws SQLException {
+        String sql = "SELECT finteger," + " (SELECT ftext FROM "
+                + DatabaseCreator.TEST_TABLE2 + " WHERE finteger = 1) as ftext"
+                + " FROM " + DatabaseCreator.TEST_TABLE2;
+        ResultSet result = statement.executeQuery(sql);
+
+        HashMap<Integer, String> value = new HashMap<Integer, String>();
+        value.put(1, DatabaseCreator.defaultString + "1");
+        value.put(2, DatabaseCreator.defaultString + "1");
+        value.put(3, DatabaseCreator.defaultString + "1");
+        value.put(4, DatabaseCreator.defaultString + "1");
+        value.put(5, DatabaseCreator.defaultString + "1");
+
+        while (result.next()) {
+            int key = result.getInt("finteger");
+            String val = result.getString("ftext");
+            assertTrue("wrong value of finteger field", value.containsKey(key));
+            assertEquals("wrong value of ftext field", value.get(key), val);
+            value.remove(key);
+        }
+        assertTrue("expected rows number doesn't equal actual rows number",
+                value.isEmpty());
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records
+     *        from a few tables
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a few tables",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectThreeTables() throws SQLException {
+        String sql = "SELECT onum, " + DatabaseCreator.ORDERS_TABLE + ".cnum"
+                + " FROM " + DatabaseCreator.SALESPEOPLE_TABLE + ", "
+                + DatabaseCreator.CUSTOMERS_TABLE + ", "
+                + DatabaseCreator.ORDERS_TABLE + " WHERE "
+                + DatabaseCreator.CUSTOMERS_TABLE + ".city <> "
+                + DatabaseCreator.SALESPEOPLE_TABLE + ".city" + " AND "
+                + DatabaseCreator.ORDERS_TABLE + ".cnum = "
+                + DatabaseCreator.CUSTOMERS_TABLE + ".cnum" + " AND "
+                + DatabaseCreator.ORDERS_TABLE + ".snum = "
+                + DatabaseCreator.SALESPEOPLE_TABLE + ".snum";
+        ResultSet result = statement.executeQuery(sql);
+
+        HashMap<Integer, Integer> value = new HashMap<Integer, Integer>();
+        value.put(3001, 2008);
+        value.put(3002, 2007);
+        value.put(3006, 2008);
+        value.put(3009, 2002);
+        value.put(3007, 2004);
+        value.put(3010, 2004);
+
+        while (result.next()) {
+            int key = result.getInt("onum");
+            int val = result.getInt("cnum");
+            assertTrue("wrong value of onum field", value.containsKey(key));
+            assertEquals("wrong value of cnum field", value.get(key),
+                    (Integer) val);
+            value.remove(key);
+        }
+        assertTrue("expected rows number doesn't equal actual rows number",
+                value.isEmpty());
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records
+     *        from a table using union
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using union",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectUnionItself() throws SQLException {
+        String sql = "SELECT b.cnum, b.cname" + " FROM "
+                + DatabaseCreator.CUSTOMERS_TABLE + " a, "
+                + DatabaseCreator.CUSTOMERS_TABLE + " b"
+                + " WHERE a.snum = 1002" + " AND b.city = a.city";
+        ResultSet result = statement.executeQuery(sql);
+
+        HashMap<Integer, String> value = new HashMap<Integer, String>();
+        value.put(2003, "Liu");
+        value.put(2004, "Grass");
+        value.put(2008, "Cisneros");
+
+        while (result.next()) {
+            int key = result.getInt("cnum");
+            String val = result.getString("cname");
+            assertTrue("wrong value of cnum field", value.containsKey(key));
+            assertEquals("wrong value of cname field", value.get(key), val);
+            value.remove(key);
+        }
+        assertTrue("expected rows number doesn't equal actual rows number",
+                value.isEmpty());
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectLeftOuterJoin(). Selects
+     *        records from a table using left join
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using left join",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectLeftOuterJoin() throws SQLException {
+        String sql = "SELECT distinct s.snum as ssnum, c.snum as ccnum FROM "
+                + DatabaseCreator.CUSTOMERS_TABLE + " c left outer join "
+                + DatabaseCreator.SALESPEOPLE_TABLE + " s on s.snum=c.snum";
+        ResultSet result = statement.executeQuery(sql);
+
+        HashMap<Integer, Integer> value = new HashMap<Integer, Integer>();
+        value.put(1001, 1001);
+        value.put(1002, 1002);
+        value.put(1003, 1003);
+        value.put(1004, 1004);
+        value.put(1007, 1007);
+
+        while (result.next()) {
+            int key = result.getInt("ssnum");
+            Object val = result.getObject("ccnum");
+            assertTrue("wrong value of ssnum field", value.containsKey(key));
+            assertEquals("wrong value of ccnum field", value.get(key),
+                    (Integer) val);
+            value.remove(key);
+        }
+        assertTrue("expected rows number doesn't equal actual rows number",
+                value.isEmpty());
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectRightOuterJoin(). Selects
+     *        records from a table using right join
+     *        
+     * TODO RIGHT and FULL OUTER JOINs are not supported       
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "tests right outer joins. RIGHT and FULL OUTER JOINs are not supported",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    @KnownFailure("not supported")
+    public void test_SelectRightOuterJoin() throws SQLException {
+        String sql = "SELECT distinct s.snum as ssnum, c.snum as ccnum FROM "
+                + DatabaseCreator.CUSTOMERS_TABLE + " c right outer join "
+                + DatabaseCreator.SALESPEOPLE_TABLE + " s on s.snum=c.snum";
+        ResultSet result = statement.executeQuery(sql);
+
+        HashMap<Integer, Integer> value = new HashMap<Integer, Integer>();
+        value.put(1001, 1001);
+        value.put(1002, 1002);
+        value.put(1003, 1003);
+        value.put(1004, 1004);
+        value.put(1007, 1007);
+        value.put(1013, null);
+
+        while (result.next()) {
+            int key = result.getInt("ssnum");
+            Object val = result.getObject("ccnum");
+            assertTrue("wrong value of ssnum field", value.containsKey(key));
+            assertEquals("wrong value of ccnum field", value.get(key),
+                    (Integer) val);
+            value.remove(key);
+        }
+        assertTrue("expected rows number doesn't equal actual rows number",
+                value.isEmpty());
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectGroupBy(). Selects records from
+     *        a table using group by
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using group by",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectGroupBy() throws SQLException {
+        String selectQuery = "SELECT rating, SUM(snum) AS sum FROM "
+                + DatabaseCreator.CUSTOMERS_TABLE + " GROUP BY rating";
+        ResultSet result = statement.executeQuery(selectQuery);
+
+        HashMap<Integer, Integer> values = new HashMap<Integer, Integer>();
+        values.put(100, 3006);
+        values.put(200, 2005);
+        values.put(300, 2009);
+
+        while (result.next()) {
+            int rating = result.getInt("rating");
+            int sum = result.getInt("sum");
+            assertTrue("Wrong value of rating field", values
+                    .containsKey(rating));
+            assertEquals("Wrong value of sum field", values.get(rating),
+                    new Integer(sum));
+            assertEquals(new Integer(sum), values.remove(rating));
+        }
+        result.close();
+        assertTrue("Result set has wrong size", values.isEmpty());
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectOrderBy(). Selects records from
+     *        a table using order by
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using order by",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectOrderBy() throws SQLException {
+        String selectQuery = "SELECT onum FROM " + DatabaseCreator.ORDERS_TABLE
+                + " ORDER BY onum";
+        ResultSet result = statement.executeQuery(selectQuery);
+
+        ArrayList<Integer> values = new ArrayList<Integer>();
+        values.add(Integer.valueOf(3001));
+        values.add(Integer.valueOf(3002));
+        values.add(Integer.valueOf(3003));
+        values.add(Integer.valueOf(3005));
+        values.add(Integer.valueOf(3006));
+        values.add(Integer.valueOf(3007));
+        values.add(Integer.valueOf(3008));
+        values.add(Integer.valueOf(3009));
+        values.add(Integer.valueOf(3010));
+        values.add(Integer.valueOf(3011));
+
+        int index = 0;
+        while (result.next()) {
+            Integer onum = result.getInt("onum");
+            assertTrue("result set doesn't contain value", values
+                    .contains(onum));
+            assertEquals("result set is not sorted", index, values
+                    .indexOf(onum));
+            index++;
+        }
+        result.close();
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectDistinct(). Selects records
+     *        from a table using distinct
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using distinct",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectDistinct() throws SQLException {
+        String selectQuery = "SELECT DISTINCT rating FROM "
+                + DatabaseCreator.CUSTOMERS_TABLE;
+        ResultSet result = statement.executeQuery(selectQuery);
+
+        HashSet<Integer> values = new HashSet<Integer>();
+        values.add(Integer.valueOf(100));
+        values.add(Integer.valueOf(200));
+        values.add(Integer.valueOf(300));
+
+        while (result.next()) {
+            Integer rating = result.getInt("rating");
+            assertTrue("result set doesn't contain value", values
+                    .contains(rating));
+            assertTrue("wrong value in the result set", values.remove(rating));
+        }
+        result.close();
+        assertTrue("Result set has wrong size", values.isEmpty());
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectAgregateFunctions(). Selects
+     *        records from a table using agregate functions
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using agregate functions",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectAgregateFunctions() throws SQLException {
+        String selectCount = "SELECT count(onum) as count FROM "
+                + DatabaseCreator.ORDERS_TABLE;
+        String selectSum = "SELECT sum(onum) as sum FROM "
+                + DatabaseCreator.ORDERS_TABLE;
+        String selectAvg = "SELECT avg(onum) as avg FROM "
+                + DatabaseCreator.ORDERS_TABLE;
+        String selectMax = "SELECT max(onum) as max FROM "
+                + DatabaseCreator.ORDERS_TABLE;
+        String selectMin = "SELECT min(onum) as min FROM "
+                + DatabaseCreator.ORDERS_TABLE;
+
+        func("count", selectCount, 10);
+        func("sum", selectSum, 30062);
+        func("avg", selectAvg, 3006);
+        func("max", selectMax, 3011);
+        func("min", selectMin, 3001);
+    }
+
+    private void func(String name, String query, int expected) {
+        int res = 0;
+        double resDouble = 0.0;
+        try {
+            ResultSet result = statement.executeQuery(query);
+            while (result.next()) {
+                res = result.getInt(name);
+                if (res != 0 ) {
+                assertEquals(expected,res);
+                break;
+                }
+                // for Double: getInt not supported yet
+                resDouble  = Double.parseDouble(result.getString(name));
+                res = (int) Math.rint(resDouble);
+                assertEquals(expected,res);
+                
+            }
+            assertFalse("wrong size of result set", result.next());
+            result.close();
+        } catch (SQLException e) {
+            fail(e.getMessage());
+        }
+    }
+
+    /**
+     * @tests SelectFunctionalityTest#test_SelectHaving(). Selects records from
+     *        a table using having
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Selects records from a table using having",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void test_SelectHaving() throws SQLException {
+        String selectQuery = "SELECT snum, max(amt) AS max FROM "
+                + DatabaseCreator.ORDERS_TABLE
+                + " GROUP BY snum HAVING max(amt) > 3000";
+        ResultSet result = statement.executeQuery(selectQuery);
+
+        HashSet<Double> values = new HashSet<Double>();
+        values.add(Double.valueOf(9891.88));
+        values.add(Double.valueOf(5160.45));
+
+        while (result.next()) {
+            Double max = result.getDouble("max");
+            assertTrue("result set doesn't contain value", values.contains(max));
+            assertTrue("wrong value in the result set", values.remove(max));
+        }
+        result.close();
+        assertTrue("Result set has wrong size", values.isEmpty());
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/StressTest.java b/sql/src/test/java/tests/java/sql/StressTest.java
new file mode 100755
index 0000000..2f1b26b
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/StressTest.java
@@ -0,0 +1,382 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.BrokenTest;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.Driver;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.Properties;
+import java.util.Vector;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+import tests.support.ThreadPool;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+@TestTargetClass(Statement.class)
+public class StressTest extends TestCase {
+    Vector<Connection> vc = new Vector<Connection>();
+
+    private static Connection conn;
+
+    private static Statement statement;
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(StressTest.class)) {
+
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                conn = Support_SQL.getConnection();
+                statement = conn.createStatement();
+                createTestTables();
+            }
+
+            protected void tearDown() throws Exception {
+                dropTestTables();
+                statement.close();
+                conn.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    DatabaseMetaData meta = conn.getMetaData();
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE2)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE2);
+                        }
+                    }
+                    statement.execute(DatabaseCreator.CREATE_TABLE2);
+                } catch (SQLException sql) {
+                    fail("Unexpected SQLException " + sql.toString());
+                }
+                return;
+            }
+
+            private void dropTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE2);
+                } catch (SQLException sql) {
+                    fail("Unexpected SQLException " + sql.toString());
+                }
+                return;
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @see junit.framework.TestCase#setUp()
+     */
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        vc.clear();
+    }
+
+    /**
+     * @see junit.framework.TestCase#tearDown()
+     */
+    @Override
+    protected void tearDown() throws Exception {
+        closeConnections();
+        statement.execute("DELETE FROM " + DatabaseCreator.TEST_TABLE2);
+        super.tearDown();
+    }
+
+    /**
+     * @tests StressTest#testManyConnectionsUsingOneThread(). Create many
+     *        connections to the DataBase using one thread.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        method = "connect",
+        clazz = Driver.class,
+        args = {String.class, Properties.class}
+    )
+    public void testManyConnectionsUsingOneThread() {
+        try {
+            int maxConnections = getConnectionNum();
+            openConnections(maxConnections);
+            assertEquals("Incorrect number of created connections",
+                    maxConnections, vc.size());
+        } catch (Exception e) {
+            fail("Unexpected Exception " + e.toString());
+        }
+    }
+
+    /**
+     * @tests StressTest#testManyConnectionsUsingManyThreads(). Create many
+     *        connections to the DataBase using some threads.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Stress test: Create many connections to the DataBase using some threads",
+        method = "connect",
+        clazz = Driver.class,
+        args = {String.class, Properties.class}
+    )
+    public void testManyConnectionsUsingManyThreads() {
+        int numTasks = getConnectionNum();
+
+        ThreadPool threadPool = new ThreadPool(numTasks);
+
+        // run example tasks
+        for (int i = 0; i < numTasks; i++) {
+            threadPool.runTask(createTask(i));
+        }
+        // close the pool and wait for all tasks to finish.
+        threadPool.join();
+        assertEquals("Unable to create a connection", numTasks, vc.size());
+        if (numTasks != Support_SQL.sqlMaxConnections) {
+            try {
+                // try to create connection n + 1
+                Connection c = Support_SQL.getConnection();
+                c.close();
+                fail("It is possible to create more than " + numTasks
+                        + "connections");
+            } catch (SQLException sql) {
+                // expected
+            }
+        }
+    }
+
+    /**
+     * @tests StressTest#testInsertOfManyRowsUsingOneThread(). Insert a lot of
+     *        records to the Database using a maximum number of connections.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        method = "connect",
+        clazz = Driver.class,
+        args = {String.class, Properties.class}
+    )
+    public void testInsertOfManyRowsUsingOneThread() {
+
+        Logger.global
+                .info("java.sql stress test: single thread and many operations.");
+        int maxConnections = getConnectionNum();
+        Logger.global.info("Opening " + maxConnections + " to database "
+                + Support_SQL.getFilename());
+        openConnections(maxConnections);
+
+        int tasksPerConnection = Support_SQL.sqlMaxTasks / maxConnections;
+        Logger.global.info("TasksPerConnection =  " + Support_SQL.sqlMaxTasks
+                + " by (maxConnections) " + maxConnections + " = "
+                + tasksPerConnection);
+        int pk = 1;
+        for (int i = 0; i < vc.size(); ++i) {
+            Logger.global.info(" creating " + tasksPerConnection
+                    + "tasks for Connection " + i);
+            Connection c = vc.elementAt(i);
+            for (int j = 0; j < tasksPerConnection; ++j) {
+                insertNewRecord(c, pk++);
+            }
+        }
+        try {
+            ResultSet rs = statement
+                    .executeQuery("SELECT COUNT(*) as counter FROM "
+                            + DatabaseCreator.TEST_TABLE2);
+            assertTrue("RecordSet is empty", rs.next());
+            assertEquals("Incorrect number of records", tasksPerConnection
+                    * maxConnections, rs.getInt("counter"));
+            rs.close();
+        } catch (SQLException sql) {
+            fail("Unexpected SQLException " + sql.toString());
+        }
+
+    }
+
+    /**
+     * @tests
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            method = "connect",
+            clazz = Driver.class,
+            args = {String.class, Properties.class}
+    )
+    @BrokenTest("Error in ThreadPool implementation threads do not get"
+            +" more tasks (only one): there seems to be a deadlock or something."
+    )
+    public void testInsertOfManyRowsUsingManyThreads() {
+        Logger.global.info("java.sql stress test: multiple threads and many operations.");
+
+        int numConnections = getConnectionNum();
+        int tasksPerConnection = Support_SQL.sqlMaxTasks / numConnections;
+        
+        Logger.global.info("Opening "+numConnections+" to database "+Support_SQL.getFilename());
+
+        ThreadPool threadPool = new ThreadPool(numConnections);
+
+        for (int i = 0; i < numConnections; ++i) {
+            Logger.global.info(" creating "+tasksPerConnection+ " tasks for Connection "+i);
+            threadPool.runTask(insertTask(numConnections, i));
+        }
+        // close the pool and wait for all tasks to finish.
+        threadPool.join();
+        assertEquals("Unable to create a connection", numConnections, vc.size());
+
+        try {
+            ResultSet rs = statement
+                    .executeQuery("SELECT COUNT(*) as counter FROM "
+                            + DatabaseCreator.TEST_TABLE2);
+            assertTrue("RecordSet is empty", rs.next());
+
+
+            assertEquals("Incorrect number of records", tasksPerConnection
+                    * numConnections, rs.getInt("counter"));
+            rs.close();
+        } catch (SQLException sql) {
+            fail("Unexpected SQLException " + sql.toString());
+
+        }
+
+    }
+
+    private int getConnectionNum() {
+        int num = Support_SQL.sqlMaxConnections;
+        try {
+            int mc = conn.getMetaData().getMaxConnections();
+            if (mc != 0) {
+                if (num != mc) {
+                    System.err.println("Will be used no more than " + mc
+                            + " connections to the DataBase");
+                }
+                num = mc;
+            }
+        } catch (SQLException sql) {
+            fail("Unexpected SQLException " + sql.toString());
+        }
+        return num;
+    }
+
+    private void openConnections(int maxConnections) {
+        int i = 0;
+        try {
+            for (; i < maxConnections; ++i) {
+                Connection c = Support_SQL.getConnection();
+                if (c == null) {
+                    assertEquals("Unable to create a connection",
+                            maxConnections, i);
+                }
+                vc.add(c);
+            }
+        } catch (SQLException sql) {
+            assertEquals("Unable to create a connection", maxConnections, i);
+        }
+        return;
+    }
+
+    private void closeConnections() {
+        int i = 0;
+        try {
+            for (; i < vc.size(); ++i) {
+                vc.elementAt(i).close();
+            }
+        } catch (SQLException sql) {
+            assertEquals("Unable to close a connection", vc.size(), i);
+        }
+        return;
+    }
+
+    private Runnable createTask(final int taskID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Connection c = Support_SQL.getConnection();
+                    if (c == null) {
+                        return;
+                    }
+                    synchronized (this) {
+                        vc.add(c);
+                    }
+                } catch (SQLException sql) {
+                    // nothing to do
+                }
+            }
+        };
+    }
+
+    private Runnable insertTask(final int numConnections, final int taskID) {
+        return new Runnable() {
+            public void run() {
+                try {
+                    Connection c = Support_SQL.getConnection();
+                    if (c == null) {
+                        return;
+                    }
+                    synchronized (this) {
+                        vc.add(c);
+                    }
+                    int tasksPerConnection = Support_SQL.sqlMaxTasks
+                            / numConnections;
+                    for (int i = 0; i < tasksPerConnection; ++i) {
+                        insertNewRecord(c, (i + 1) + tasksPerConnection
+                                * taskID);
+                    }
+                } catch (SQLException sql) {
+                    // do nothing
+                }
+            }
+        };
+    }
+
+    private void insertNewRecord(Connection c, int pk) {
+        String query = "INSERT INTO " + DatabaseCreator.TEST_TABLE2
+                + "(finteger, ftext, fcharacter, fdecimal, fnumeric,"
+                + " fsmallint, ffloat, freal, fdouble, fdate, ftime)"
+                + " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)";
+        try {
+            PreparedStatement ps = c.prepareStatement(query);
+            ps.setInt(1, pk);
+            ps.setString(2, "text");
+            ps.setString(3, "chr");
+            ps.setFloat(4, 0.1f);
+            ps.setFloat(5, 0.2f);
+            ps.setShort(6, (short) 3);
+            ps.setFloat(7, 0.4f);
+            ps.setDouble(8, 0.5);
+            ps.setDouble(9, 0.6);
+            ps.setDate(10, new java.sql.Date(System.currentTimeMillis()));
+            ps.setTime(11, new java.sql.Time(System.currentTimeMillis()));
+            ps.execute();
+            ps.close();
+        } catch (SQLException sql) {
+            fail("Unexpected SQLException " + sql.toString());
+        }
+        return;
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java
new file mode 100755
index 0000000..2a94f08
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java
@@ -0,0 +1,483 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.math.BigDecimal;
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.HashSet;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+@TestTargetClass(Statement.class)
+public class UpdateFunctionalityTest extends TestCase {
+
+    private static final int numberOfRecords = 20;
+
+    private static Connection conn;
+
+    private static Statement statement;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        DatabaseCreator.fillTestTable1(conn, numberOfRecords);
+        DatabaseCreator.fillTestTable2(conn, numberOfRecords);
+    }
+
+    protected void tearDown() throws Exception {
+        String deleteQuery1 = "DELETE FROM " + DatabaseCreator.TEST_TABLE1;
+        String deleteQuery2 = "DELETE FROM " + DatabaseCreator.TEST_TABLE2;
+
+        statement.execute(deleteQuery1);
+        statement.execute(deleteQuery2);
+        super.tearDown();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                UpdateFunctionalityTest.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                statement.close();
+                conn.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    DatabaseMetaData meta = conn.getMetaData();
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.TEST_TABLE1)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE2)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE2);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE3)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE3);
+                        }
+                    }
+                    userTab.close();
+
+                    statement.execute(DatabaseCreator.CREATE_TABLE3);
+                    statement.execute(DatabaseCreator.CREATE_TABLE2);
+                    statement.execute(DatabaseCreator.CREATE_TABLE1);
+
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE2);
+                    statement.execute(DatabaseCreator.DROP_TABLE3);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate1(). Updates all values in one
+     *        column in the table
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates all values in one column in the table",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates all values in one column in the table",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate1() {
+        String newValue = "newValue";
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field1='" + newValue + "'";
+        try {
+            int num = statement.executeUpdate(updateQuery);
+            assertEquals("Not all records in the database were updated",
+                    numberOfRecords, num);
+            String selectQuery = "SELECT field1 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+                assertEquals("The field field1 was not updated", newValue,
+                        result.getString("field1"));
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate2(). Updates values in one
+     *        column in the table using where condition in update command
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in one column in the table using where condition in update command",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in one column in the table using where condition in update command",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate2() {
+        String newValue = "newValue";
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field1='" + newValue + "' WHERE (id > 2) and (id < 10)";
+        try {
+            int num = statement.executeUpdate(updateQuery);
+            int expectedUpdated = 7;
+            assertEquals("Not all records in the database were updated",
+                    expectedUpdated, num);
+            String selectQuery = "SELECT * FROM " + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+                int id = result.getInt("id");
+                String field1 = result.getString("field1");
+                if ((id > 2) && (id < 10)) {
+                    assertEquals("The field field1 was not updated", newValue,
+                            field1);
+                } else {
+                    assertEquals("The field field1 was not updated",
+                            DatabaseCreator.defaultString + id, field1);
+                }
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate3(). Updates values in a several
+     *        columns in the table
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in a several columns in the table",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in a several columns in the table",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate3() {
+        int newValue1 = -1;
+        int newValue2 = -2;
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2=" + newValue1 + ", field3=" + newValue2;
+        try {
+            int num = statement.executeUpdate(updateQuery);
+            assertEquals("Not all records in the database were updated",
+                    numberOfRecords, num);
+            String selectQuery = "SELECT field2, field3 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+           // TODO getBigDecimal is not supported
+//                assertEquals("The field field2 was not updated", newValue1,
+//                        result.getBigDecimal("field2").intValue());
+//                assertEquals("The field field3 was not updated", newValue2,
+//                        result.getBigDecimal("field3").intValue());
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate4(). Updates values in a several
+     *        columns in the table using where condition in update command
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in a several columns in the table using where condition in update command",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in a several columns in the table using where condition in update command",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate4() {
+        int newValue1 = -1;
+        int newValue2 = -2;
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2=" + newValue1 + ", field3=" + newValue2
+                + " WHERE id > 10";
+        try {
+            int num = statement.executeUpdate(updateQuery);
+            int expectedUpdated = 9;
+            assertEquals("Not all records in the database were updated",
+                    expectedUpdated, num);
+            String selectQuery = "SELECT id, field2, field3 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+                int id = result.getInt("id");
+                // TODO getBigDecimal is not supported
+//                int value2 = result.getBigDecimal("field2").intValue();
+//                int value3 = result.getBigDecimal("field3").intValue();
+//                if (id > expectedUpdated + 1) {
+//                    assertEquals("The field field2 was not updated", newValue1,
+//                            value2);
+//                    assertEquals("The field field3 was not updated", newValue2,
+//                            value3);
+//                } else {
+//                    assertEquals("The field field2 was not updated", id, value2);
+//                    assertEquals("The field field3 was not updated", id, value3);
+//                }
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate5(). Updates values in one
+     *        columns in the table using condition
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in one columns in the table using condition",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates values in one columns in the table using condition",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate5() {
+        int factor = 3;
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2=field2 *" + factor;
+        try {
+            String selectQuery = "SELECT field2 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            HashSet<BigDecimal> values = new HashSet<BigDecimal>();
+            // TODO getBigDecimal is not supported
+//            while (result.next()) {
+//                values.add(BigDecimal.valueOf(result.getBigDecimal("field2")
+//                        .intValue()
+//                        * factor));
+//            }
+
+            int num = statement.executeUpdate(updateQuery);
+            assertEquals("Not all records in the database were updated",
+                    numberOfRecords, num);
+            result = statement.executeQuery(selectQuery);
+            // TODO getBigDecimal is not supported
+//            while (result.next()) {
+//                BigDecimal value = result.getBigDecimal("field2");
+//                assertTrue("Wrong value of field2 after update"
+//                        + value.intValue(), values.remove(value));
+//            }
+            assertTrue("Not all records were updated", values.isEmpty());
+
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate6(). Sets value of field2 to
+     *        default
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Sets value of field2 to default",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Sets value of field2 to default",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate6() {
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2='1'";
+        try {
+
+            int num = statement.executeUpdate(updateQuery);
+            assertEquals("Not all records in the database were updated",
+                    numberOfRecords, num);
+            String selectQuery = "SELECT field2 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            // TODO getBigDecimal is not supported
+//            while (result.next()) {
+//                assertEquals("value of field2 should be default ",
+//                        DatabaseCreator.defaultInt, result.getBigDecimal(
+//                                "field2").intValue());
+//            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate7(). Updates records in the
+     *        table using subquery in update command
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates records in the table using subquery in update command",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates records in the table using subquery in update command",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate7() {
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2='1' WHERE id < ( SELECT COUNT(*) FROM "
+                + DatabaseCreator.TEST_TABLE2 + " WHERE finteger > 15)";
+        try {
+            int num = statement.executeUpdate(updateQuery);
+            int expectedUpdated = 4;
+            assertEquals("Not all records in the database were updated",
+                    expectedUpdated, num);
+            String selectQuery = "SELECT id, field2 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+           // TODO getBigDecimal is not supported
+//                int value = result.getBigDecimal("field2").intValue();
+//                int id = result.getInt("id");
+//                if (id < expectedUpdated) {
+//                    assertEquals("value of field2 should be default ",
+//                            DatabaseCreator.defaultInt, value);
+//                } else {
+//                    assertEquals("wrong value of field2", id, value);
+//                }
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest#testUpdate8(). Sets value of field2 to
+     *        NULL
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Sets value of field2 to NULL",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Sets value of field2 to NULL",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate8() {
+        String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
+                + " SET field2=NULL";
+        try {
+
+            int num = statement.executeUpdate(updateQuery);
+            assertEquals("Not all records in the database were updated",
+                    numberOfRecords, num);
+            String selectQuery = "SELECT field2 FROM "
+                    + DatabaseCreator.TEST_TABLE1;
+            ResultSet result = statement.executeQuery(selectQuery);
+            while (result.next()) {
+                assertNull("value of field2 should be NULL", result
+                        .getObject("field2"));
+            }
+            result.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception" + e.getMessage());
+        }
+    }
+}
diff --git a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java
new file mode 100755
index 0000000..f14bbfa
--- /dev/null
+++ b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java
@@ -0,0 +1,387 @@
+/*
+ * 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.java.sql;
+
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Connection;
+import java.sql.DatabaseMetaData;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+import tests.support.DatabaseCreator;
+import tests.support.Support_SQL;
+
+import junit.extensions.TestSetup;
+import junit.framework.Test;
+import junit.framework.TestCase;
+import junit.framework.TestSuite;
+
+@TestTargetClass(Statement.class)
+public class UpdateFunctionalityTest2 extends TestCase {
+
+    private static Connection conn = null;
+
+    private static Statement statement = null;
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        DatabaseCreator.fillParentTable(conn);
+        DatabaseCreator.fillSimpleTable3(conn);
+        DatabaseCreator.fillSimpleTable1(conn);
+    }
+
+    protected void tearDown() throws Exception {
+        statement.execute("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE3);
+        statement.execute("DELETE FROM " + DatabaseCreator.SIMPLE_TABLE1);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKCASCADE_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE);
+        statement.execute("DELETE FROM " + DatabaseCreator.TEST_TABLE5);
+        super.tearDown();
+    }
+
+    public static Test suite() {
+        TestSetup setup = new TestSetup(new TestSuite(
+                UpdateFunctionalityTest2.class)) {
+            protected void setUp() throws Exception {
+                Support_SQL.loadDriver();
+                try {
+                    conn = Support_SQL.getConnection();
+                    statement = conn.createStatement();
+                    createTestTables();
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            protected void tearDown() throws Exception {
+                deleteTestTables();
+                statement.close();
+                conn.close();
+            }
+
+            private void createTestTables() {
+                try {
+                    DatabaseMetaData meta = conn.getMetaData();
+                    ResultSet userTab = meta.getTables(null, null, null, null);
+
+                    while (userTab.next()) {
+                        String tableName = userTab.getString("TABLE_NAME");
+                        if (tableName.equals(DatabaseCreator.PARENT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_PARENT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKCASCADE_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                        } else if (tableName
+                                .equals(DatabaseCreator.FKSTRICT_TABLE)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                        } else if (tableName
+                                .equals(DatabaseCreator.SIMPLE_TABLE1)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_SIMPLE1);
+                        } else if (tableName
+                                .equals(DatabaseCreator.SIMPLE_TABLE3)) {
+                            statement
+                                    .execute(DatabaseCreator.DROP_TABLE_SIMPLE3);
+                        } else if (tableName
+                                .equals(DatabaseCreator.TEST_TABLE5)) {
+                            statement.execute(DatabaseCreator.DROP_TABLE5);
+                        }
+                    }
+                    userTab.close();
+                    statement.execute(DatabaseCreator.CREATE_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE3);
+                    statement.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
+                    statement.execute(DatabaseCreator.CREATE_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+
+            private void deleteTestTables() {
+                try {
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKCASCADE);
+                    statement.execute(DatabaseCreator.DROP_TABLE_FKSTRICT);
+                    statement.execute(DatabaseCreator.DROP_TABLE_PARENT);
+                    statement.execute(DatabaseCreator.DROP_TABLE_SIMPLE3);
+                    statement.execute(DatabaseCreator.DROP_TABLE_SIMPLE1);
+                    statement.execute(DatabaseCreator.DROP_TABLE5);
+                } catch (SQLException e) {
+                    fail("Unexpected SQLException " + e.toString());
+                }
+            }
+        };
+        return setup;
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate1(). Updates row with no
+     *        referencing ones and RESTRICT action
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Updates row with no referencing ones and RESTRICT action",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    public void testUpdate1() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.execute("UPDATE " + DatabaseCreator.PARENT_TABLE
+                + " SET id = 4 WHERE id = 3");
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate2(). Attempts to update row
+     *        with referencing ones and RESTRICT action - expecting SQLException
+     *        
+     *  TODO not supported       
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Attempts to update row with referencing ones and RESTRICT action - expecting SQLException",
+            method = "execute",
+            args = {java.lang.String.class}
+        )
+    @KnownFailure("not supported")
+    public void testUpdate2() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        try {
+            statement.executeUpdate("UPDATE " + DatabaseCreator.PARENT_TABLE
+                    + " SET id = 5 WHERE id = 1;");
+            fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate3(). Deletes all referencing
+     *        rows and then updates referenced one
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Deletes all referencing rows and then updates referenced one",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    public void testUpdate3() throws SQLException {
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
+                + " WHERE name_id = 1;");
+        statement.execute("UPDATE " + DatabaseCreator.PARENT_TABLE
+                + " SET id = 5 WHERE id = 1;");
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate4(). Attempts to set incorrect
+     *        foreign key value - expecting SQLException
+     *        
+     *  TODO foreign key functionality is not supported      
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Attempts to set incorrect foreign key value - expecting SQLException",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+    )
+    @KnownFailure("not supported")
+   public void testUpdate4() throws SQLException {
+       DatabaseCreator.fillFKStrictTable(conn);
+        try {
+            statement.executeUpdate("UPDATE " + DatabaseCreator.FKSTRICT_TABLE
+                    + " SET name_id = 6 WHERE name_id = 2");
+            fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate5(). Updates row with
+     *        referencing ones and CASCADE action - expecting that all
+     *        referencing rows will also be updated
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates row with referencing ones and CASCADE action - expecting that all referencing rows will also be updated",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates row with referencing ones and CASCADE action - expecting that all referencing rows will also be updated",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate5() throws SQLException {
+        DatabaseCreator.fillFKCascadeTable(conn);
+        statement.executeUpdate("UPDATE " + DatabaseCreator.PARENT_TABLE
+                + " SET id = 5 WHERE id = 1;");
+
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) " + "FROM "
+                + DatabaseCreator.FKCASCADE_TABLE + " WHERE name_id = 1;");
+        r.next();
+        assertEquals("Should be 2 rows", 2, r.getInt(1));
+        r = statement.executeQuery("SELECT COUNT(*) " + "FROM "
+                + DatabaseCreator.FKCASCADE_TABLE + " WHERE name_id = 5;");
+        r.next();
+        assertEquals("Should be 0 rows", 0, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate6(). Attempts to set incorrect
+     *        foreign key value to row with CASCADE action - expecting
+     *        SQLException
+     *        
+     *  TODO Foreign key functionality is not supported       
+     */
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Attempts to set incorrect\n" + 
+                    "foreign key value to row with CASCADE action - expecting SQLException: not supported",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        )
+    @KnownFailure("not supported")
+    public void testUpdate6() throws SQLException {
+        DatabaseCreator.fillFKCascadeTable(conn);
+        try {
+            statement.executeUpdate("UPDATE " + DatabaseCreator.FKCASCADE_TABLE
+                    + " SET name_id = 6 WHERE name_id = 2");
+            fail("expecting SQLException");
+        } catch (SQLException ex) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate7(). Updates table using
+     *        subquery in WHERE clause
+     *        
+     *  TODO Foreign key functionality is not supported       
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates table using subquery in WHERE clause. Not supported: FK",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates table using subquery in WHERE clause. Not supported: FK.",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        )
+    })
+    @KnownFailure("not supported")
+   public void testUpdate7() throws SQLException {
+        
+        DatabaseCreator.fillFKStrictTable(conn);
+        statement.executeUpdate("UPDATE " + DatabaseCreator.FKSTRICT_TABLE
+                + " SET value = 'updated' WHERE name_id = ANY (SELECT id FROM "
+                + DatabaseCreator.PARENT_TABLE + " WHERE id > 1)");
+        ResultSet r = statement.executeQuery("SELECT COUNT(*) FROM "
+                + DatabaseCreator.FKSTRICT_TABLE + " WHERE value = 'updated';");
+        r.next();
+        assertEquals("Should be 1 row", 1, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate8(). Updates table using scalar
+     *        subquery as new field value
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates table using scalar subquery as new field value",
+            method = "executeQuery",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Functionality test: Updates table using scalar subquery as new field value",
+            method = "executeUpdate",
+            args = {java.lang.String.class}
+        )
+    })
+    public void testUpdate8() throws SQLException {
+        statement.executeUpdate("UPDATE " + DatabaseCreator.SIMPLE_TABLE3
+                + " SET speed = (SELECT MAX(speed) FROM "
+                + DatabaseCreator.SIMPLE_TABLE1
+                + ") WHERE id = (SELECT id FROM "
+                + DatabaseCreator.SIMPLE_TABLE1
+                + " WHERE speed = (SELECT MAX(speed) FROM "
+                + DatabaseCreator.SIMPLE_TABLE1 + "))");
+        ResultSet r = statement.executeQuery("SELECT id FROM "
+                + DatabaseCreator.SIMPLE_TABLE3
+                + " WHERE speed = (SELECT MAX(speed) FROM "
+                + DatabaseCreator.SIMPLE_TABLE1 + ");");
+        r.next();
+        assertEquals("Incorrect id updated", 1, r.getInt(1));
+        r.close();
+    }
+
+    /**
+     * @tests UpdateFunctionalityTest2#testUpdate9(). Updates table using
+     *        PreparedStatement
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Functionality test: Updates table using PreparedStatement",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    public void testUpdate9() throws SQLException {
+        DatabaseCreator.fillTestTable5(conn);
+        PreparedStatement stat = conn.prepareStatement("UPDATE "
+                + DatabaseCreator.TEST_TABLE5
+                + " SET testValue = ? WHERE testID = ?");
+        stat.setString(1, "1");
+        stat.setInt(2, 1);
+        stat.execute();
+        stat.setString(1, "2");
+        stat.setInt(2, 2);
+        stat.execute();
+        ResultSet r = statement.executeQuery("SELECT testId, testValue FROM "
+                + DatabaseCreator.TEST_TABLE5
+                + " WHERE testID < 3 ORDER BY testID");
+        while (r.next()) {
+            assertEquals("Incorrect value was returned", new Integer(r
+                    .getInt(1)).toString(), r.getString(2));
+        }
+        r.close();
+        stat.close();
+    }
+}
diff --git a/sql/src/test/java/tests/javax/sql/ConnectionEventListenerTest.java b/sql/src/test/java/tests/javax/sql/ConnectionEventListenerTest.java
new file mode 100644
index 0000000..a89b026
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/ConnectionEventListenerTest.java
@@ -0,0 +1,42 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.ConnectionEvent;
+import javax.sql.ConnectionEventListener;
+
+@TestTargetClass(ConnectionEventListener.class)
+public class ConnectionEventListenerTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.ConnectionEventListener#connectionClosed(javax.sql.ConnectionEvent)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "connectionClosed",
+        args = {javax.sql.ConnectionEvent.class}
+    )
+    public void testConnectionClosed() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @test {@link javax.sql.ConnectionEventListener#connectionErrorOccurred(ConnectionEvent)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "connectionErrorOccurred",
+        args = {javax.sql.ConnectionEvent.class}
+    )
+    public void testConnectionErrorOccurred() {
+        fail("Not yet implemented"); // TODO
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/ConnectionPoolDataSourceTest.java b/sql/src/test/java/tests/javax/sql/ConnectionPoolDataSourceTest.java
new file mode 100644
index 0000000..7dafc46
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/ConnectionPoolDataSourceTest.java
@@ -0,0 +1,96 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.io.PrintWriter;
+
+import javax.sql.ConnectionPoolDataSource;
+
+
+@TestTargetClass(ConnectionPoolDataSource.class)
+public class ConnectionPoolDataSourceTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getLoginTimeout()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getLoginTimeout",
+        args = {}
+    )
+    public void testGetLoginTimeout() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getLogWriter()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getLogWriter",
+        args = {}
+    )
+    public void testGetLogWriter() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getPooledConnection()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getPooledConnection",
+        args = {}
+    )
+    public void testGetPooledConnection() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getPooledConnection(String, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getPooledConnection",
+        args = {String.class, String.class}
+    )
+    public void testGetPooledConnectionStringString() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#setLoginTimeout(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setLoginTimeout",
+        args = {int.class}
+    )
+    public void testSetLoginTimeout() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#setLogWriter(java.io.PrintWriter)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setLogWriter",
+        args = {java.io.PrintWriter.class}
+    )
+    public void testSetLogWriter() {
+        fail("Not yet implemented"); // NOT_FEASIBLE
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/DataSourceTest.java b/sql/src/test/java/tests/javax/sql/DataSourceTest.java
new file mode 100644
index 0000000..8aeb666
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/DataSourceTest.java
@@ -0,0 +1,96 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.io.PrintWriter;
+
+import javax.sql.DataSource;
+
+@TestTargetClass(DataSource.class)
+public class DataSourceTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.DataSource#getConnection()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getConnection",
+        args = {}
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * @tests {@link javax.sql.DataSource#getConnection(String, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getConnection",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    public void testGetConnectionStringString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#getLoginTimeout()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getLoginTimeout",
+        args = {}
+    )
+    public void testGetLoginTimeout() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#getLogWriter()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getLogWriter",
+        args = {}
+    )
+    public void testGetLogWriter() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#setLoginTimeout(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setLoginTimeout",
+        args = {int.class}
+    )
+    public void testSetLoginTimeout() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.DataSource#setLogWriter(java.io.PrintWriter)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setLogWriter",
+        args = {PrintWriter.class}
+    )
+    public void testSetLogWriter() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/PooledConnectionTest.java b/sql/src/test/java/tests/javax/sql/PooledConnectionTest.java
new file mode 100644
index 0000000..4eb09fb
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/PooledConnectionTest.java
@@ -0,0 +1,68 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import javax.sql.ConnectionEventListener;
+import javax.sql.PooledConnection;
+
+@TestTargetClass(PooledConnection.class)
+public class PooledConnectionTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#addConnectionEventListener(javax.sql.ConnectionEventListener)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "addConnectionEventListener",
+        args = {javax.sql.ConnectionEventListener.class}
+    )
+    public void testAddConnectionEventListener() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#close()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "close",
+        args = {}
+    )
+    public void testClose() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#getConnection()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getConnection",
+        args = {}
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.PooledConnection#removeConnectionEventListener(ConnectionEventListener)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "removeConnectionEventListener",
+        args = {javax.sql.ConnectionEventListener.class}
+    )
+    public void testRemoveConnectionEventListener() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetInternalTest.java b/sql/src/test/java/tests/javax/sql/RowSetInternalTest.java
new file mode 100644
index 0000000..ff9de34
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetInternalTest.java
@@ -0,0 +1,78 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSetInternal;
+import javax.sql.RowSetMetaData;
+
+@TestTargetClass(RowSetInternal.class)
+public class RowSetInternalTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getConnection()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getConnection",
+        args = {}
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getOriginal()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getOriginal",
+        args = {}
+    )
+    public void testGetOriginal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getOriginalRow()}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getOriginalRow",
+        args = {}
+    )
+    public void testGetOriginalRow() {
+        fail("Not yet implemented");
+    }
+
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getParams",
+      args = {}
+    )
+    public void testGetParams() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#setMetaData(javax.sql.RowSetMetaData)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setMetaData",
+        args = {javax.sql.RowSetMetaData.class}
+    )
+    public void testSetMetaData() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetListenerTest.java b/sql/src/test/java/tests/javax/sql/RowSetListenerTest.java
new file mode 100644
index 0000000..d238a42
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetListenerTest.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2008 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.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSetEvent;
+import javax.sql.RowSetListener;
+
+/**
+ *
+ */
+@TestTargetClass(RowSetListener.class)
+public class RowSetListenerTest extends TestCase {
+
+    /**
+     * Test method for {@link javax.sql.RowSetListener#cursorMoved(javax.sql.RowSetEvent)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "cursorMoved",
+        args = {javax.sql.RowSetEvent.class}
+    )
+    public void testCursorMoved() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link javax.sql.RowSetListener#rowChanged(javax.sql.RowSetEvent)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "rowChanged",
+        args = {javax.sql.RowSetEvent.class}
+    )
+    public void testRowChanged() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link javax.sql.RowSetListener#rowSetChanged(javax.sql.RowSetEvent)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "rowSetChanged",
+        args = {javax.sql.RowSetEvent.class}
+    )
+    public void testRowSetChanged() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetMetaDataTest.java b/sql/src/test/java/tests/javax/sql/RowSetMetaDataTest.java
new file mode 100644
index 0000000..0a3db18
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetMetaDataTest.java
@@ -0,0 +1,241 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSetMetaData;
+
+/**
+ * @author AGR
+ *
+ */
+@TestTargetClass(RowSetMetaData.class)
+public class RowSetMetaDataTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setAutoIncrement(int, boolean)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setAutoIncrement",
+        args = {int.class, boolean.class}
+    )
+    public void testSetAutoIncrement() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCaseSensitive(int, boolean)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setCaseSensitive",
+        args = {int.class, boolean.class}
+    )
+    public void testSetCaseSensitive() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCatalogName(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setCatalogName",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetCatalogName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnCount(int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnCount",
+        args = {int.class}
+    )
+    public void testSetColumnCount() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnDisplaySize(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnDisplaySize",
+        args = {int.class, int.class}
+    )
+    public void testSetColumnDisplaySize() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnLabel(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnLabel",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetColumnLabel() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnName(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnName",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetColumnName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnType(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnType",
+        args = {int.class, int.class}
+    )
+    public void testSetColumnType() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnTypeName(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setColumnTypeName",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetColumnTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCurrency(int, boolean)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setCurrency",
+        args = {int.class, boolean.class}
+    )
+    public void testSetCurrency() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setNullable(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setNullable",
+        args = {int.class, int.class}
+    )
+    public void testSetNullable() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setPrecision(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setPrecision",
+        args = {int.class, int.class}
+    )
+    public void testSetPrecision() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setScale(int, int)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setScale",
+        args = {int.class, int.class}
+    )
+    public void testSetScale() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSchemaName(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setSchemaName",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetSchemaName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSearchable(int, boolean)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setSearchable",
+        args = {int.class, boolean.class}
+    )
+    public void testSetSearchable() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSigned(int, boolean)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setSigned",
+        args = {int.class, boolean.class}
+    )
+    public void testSetSigned() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setTableName(int, String)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTableName",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetTableName() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetReaderTest.java b/sql/src/test/java/tests/javax/sql/RowSetReaderTest.java
new file mode 100644
index 0000000..0a24234
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetReaderTest.java
@@ -0,0 +1,29 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSetInternal;
+import javax.sql.RowSetReader;
+
+@TestTargetClass(RowSetReader.class)
+public class RowSetReaderTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.RowSetReader#readData(RowSetInternal)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "readData",
+        args = {javax.sql.RowSetInternal.class}
+    )
+    public void testReadData() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetTest.java b/sql/src/test/java/tests/javax/sql/RowSetTest.java
new file mode 100644
index 0000000..3dc2ba7
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetTest.java
@@ -0,0 +1,624 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Map;
+
+import javax.sql.RowSet;
+import javax.sql.RowSetListener;
+
+/**
+ *No Implementation class of this interface is available: tests not feasible
+ */
+@TestTargetClass(RowSet.class)
+public class RowSetTest extends TestCase {
+    
+    /**
+     * @tests {@link javax.sql.RowSet#addRowSetListener(javax.sql.RowSetListener)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "addRowSetListener",
+        args = {javax.sql.RowSetListener.class}
+    )
+    public void testAddRowSetListener() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * @tests {@link javax.sql.RowSet#clearParameters()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "clearParameters",
+        args = {}
+    )
+    public void testClearParameters() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#addRowSetListener(javax.sql.RowSetListener)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "execute",
+        args = {}
+    )
+    public void testExecute() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#getCommand()}.
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setCommand",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getCommand",
+            args = {}
+        )
+    })
+    public void testSetGetCommand() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#getDataSourceName()}.
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setDataSourceName",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getDataSourceName",
+            args = {}
+        )
+    })
+    public void testSetGetDataSourceName() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getEscapeProcessing",
+        args = {}
+    )
+    public void testSetGetEscapeProcessing() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getMaxFieldSize",
+        args = {}
+    )
+    public void testSetGetMaxFieldSize() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getMaxRows",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setMaxRows",
+            args = {int.class}
+        )
+    })
+    public void testSetGetMaxRows() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getPassword",
+        args = {}
+    )
+    public void testSetGetPassword() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getQueryTimeout",
+        args = {}
+    )
+    public void testSetGetQueryTimeout() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getTransactionIsolation",
+        args = {}
+    )
+    public void testSetGetTransactionIsolation() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getTypeMap",
+        args = {}
+    )
+    public void testSetGetTypeMap() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setUrl",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getUrl",
+            args = {}
+        )
+    })
+    public void testSetGetUrl() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setUsername",
+            args = {java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getUsername",
+            args = {}
+        )
+    })
+    public void testSetGetUsername() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "isReadOnly",
+        args = {}
+    )
+    public void testIsReadOnly() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "removeRowSetListener",
+        args = {javax.sql.RowSetListener.class}
+    )
+    public void testRemoveRowSetListener() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setArray",
+        args = {int.class, java.sql.Array.class}
+    )
+    public void testSetArray() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setAsciiStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    public void testSetGetAsciiStream() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setBigDecimal",
+        args = {int.class, java.math.BigDecimal.class}
+    )
+    public void testSetGetBigDecimal() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setBinaryStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    public void testSetGetBinaryStream() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setBlob",
+        args = {int.class, java.sql.Blob.class}
+    )
+    public void testSetGetBlob() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setBoolean",
+        args = {int.class, boolean.class}
+    )
+    public void testSetGetBoolean() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setByte",
+        args = {int.class, byte.class}
+    )
+    public void testSetGetByte() {
+        fail("Not yet implemented");
+    }
+     
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setBytes",
+        args = {int.class, byte[].class}
+    )
+    public void testSetGetBytes() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setCharacterStream",
+        args = {int.class, java.io.Reader.class, int.class}
+    )
+    public void testSetGetCharacterStream() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setClob",
+        args = {int.class, java.sql.Clob.class}
+    )
+    public void testSetGetClob() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setConcurrency",
+        args = {int.class}
+    )
+    public void testSetGetConcurrency() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setDate",
+        args = {int.class, java.sql.Date.class}
+    )
+    public void testSetGetDateIntDate() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setDate",
+        args = {int.class, java.sql.Date.class, java.util.Calendar.class}
+    )
+    public void testSetDateIntDateCalendar() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setEscapeProcessing",
+        args = {boolean.class}
+    )
+    public void testSetEscapeProcessing() {
+        
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setDouble",
+        args = {int.class, double.class}
+    )
+    public void testSetGetDouble() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setFloat",
+        args = {int.class, float.class}
+    )
+    public void testSetGetFloat() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setInt",
+        args = {int.class, int.class}
+    )
+    public void testSetGetInt() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setLong",
+        args = {int.class, long.class}
+    )
+    public void testSetGetLong() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "getMaxFieldSize",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "setMaxFieldSize",
+            args = {int.class}
+        )
+    })
+    public void testSetGetGetMaxFieldSize() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setNull",
+        args = {int.class, int.class}
+    )
+    public void testSetGetNullIntInt() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setNull",
+        args = {int.class, int.class, java.lang.String.class}
+    )
+    public void testSetGetNullIntIntString() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class}
+    )
+    public void testSetGetObjectIntObject() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class, int.class}
+    )
+    public void testSetGetObjectIntObjectInt() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class, int.class, int.class}
+    )
+    public void testSetGetObjectIntObjectIntInt() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setPassword",
+        args = {java.lang.String.class}
+    )
+    public void testSetPassword() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setQueryTimeout",
+        args = {int.class}
+    )
+    public void testSetQueryTimeout() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setReadOnly",
+        args = {boolean.class}
+    )
+    public void testSetReadOnly() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setRef",
+        args = {int.class, java.sql.Ref.class}
+    )
+    public void testSetRef() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setShort",
+        args = {int.class, short.class}
+    )
+    public void testSetShort() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetString() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTime",
+        args = {int.class, java.sql.Time.class}
+    )
+    public void testSetTimeIntTime() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTime",
+        args = {int.class, java.sql.Time.class, java.util.Calendar.class}
+    )
+    public void testSetTimeIntTimeCalendar() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTimestamp",
+        args = {int.class, java.sql.Timestamp.class}
+    )
+    public void testSetTimestampIntTimestamp() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTimestamp",
+        args = {int.class, java.sql.Timestamp.class, java.util.Calendar.class}
+    )
+    public void testSetTimestampIntTimestampCalendar() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTransactionIsolation",
+        args = {int.class}
+    )
+    public void testSetTransactionIsolation() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setType",
+        args = {int.class}
+    )
+    public void testSetType() {
+        fail("Not yet implemented");
+    }
+    
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setTypeMap",
+        args = {java.util.Map.class}
+    )
+    public void testSetTypeMap() {
+        fail("Not yet implemented");
+    }
+}
diff --git a/sql/src/test/java/tests/javax/sql/RowSetWriterTest.java b/sql/src/test/java/tests/javax/sql/RowSetWriterTest.java
new file mode 100644
index 0000000..1b9f972
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetWriterTest.java
@@ -0,0 +1,29 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSetInternal;
+import javax.sql.RowSetWriter;
+
+@TestTargetClass(RowSetWriter.class)
+public class RowSetWriterTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.RowSetWriter#writeData(javax.sql.RowSetInternal)}
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "writeData",
+        args = {javax.sql.RowSetInternal.class}
+    )
+    public void testWriteData() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/AllTests.java b/sql/src/test/java/tests/sql/AllTests.java
new file mode 100644
index 0000000..7693d2d
--- /dev/null
+++ b/sql/src/test/java/tests/sql/AllTests.java
@@ -0,0 +1,48 @@
+/* Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You 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 junit.framework.Test;
+import junit.framework.TestSuite;
+
+/**
+ * Test suite that includes all tests for the Math project.
+ */
+public class AllTests {
+
+    public static void main(String[] args) {
+        junit.textui.TestRunner.run(AllTests.suite());
+    }
+
+    public static Test suite() {
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("All SQL test suites");
+        // $JUnit-BEGIN$
+        suite.addTest(org.apache.harmony.sql.tests.java.sql.AllTests.suite());
+        suite.addTest(org.apache.harmony.sql.tests.javax.sql.AllTests.suite());
+        suite.addTest(tests.java.sql.AllTests.suite());
+        suite.addTest(tests.SQLite.AllTests.suite());
+        
+        suite.addTestSuite(tests.sql.ConnectionTest.class);
+        suite.addTestSuite(tests.sql.PreparedStatementTest.class);
+        suite.addTestSuite(tests.sql.ResultSetGetterTests.class);
+        suite.addTestSuite(tests.sql.ResultSetMetaDataTest.class);
+        suite.addTestSuite(tests.sql.ResultSetTest.class);
+        suite.addTestSuite(tests.sql.StatementTest.class);
+        // $JUnit-END$
+        return suite;
+    }
+}
diff --git a/sql/src/test/java/tests/sql/ArrayTest.java b/sql/src/test/java/tests/sql/ArrayTest.java
new file mode 100644
index 0000000..f3b49d6
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ArrayTest.java
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Array;
+import java.util.Map;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(Array.class)
+public class ArrayTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Array#getArray()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getArray",
+      args = {}
+    )
+    public void testGetArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getArray(long, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getArray",
+      args = {long.class, int.class}
+    )
+    public void testGetArrayLongInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getArray(long, int, java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getArray",
+      args = {long.class, int.class, Map.class}
+    )
+    public void testGetArrayLongIntMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getArray(java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getArray",
+      args = {Map.class}
+    )
+    public void testGetArrayMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getBaseType()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBaseType",
+      args = {}
+    )
+    public void testGetBaseType() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getBaseTypeName()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBaseTypeName",
+      args = {}
+    )
+    public void testGetBaseTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getResultSet()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getResultSet",
+      args = {}
+    )
+    public void testGetResultSet() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getResultSet(long, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getResultSet",
+      args = {long.class, int.class}
+    )
+    public void testGetResultSetLongInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getResultSet(long, int, java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getResultSet",
+      args = {long.class, int.class, Map.class}
+    )
+    public void testGetResultSetLongIntMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Array#getResultSet(java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getResultSet",
+      args = {Map.class}
+    )
+    public void testGetResultSetMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/BlobTest.java b/sql/src/test/java/tests/sql/BlobTest.java
new file mode 100644
index 0000000..43fb2a6
--- /dev/null
+++ b/sql/src/test/java/tests/sql/BlobTest.java
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Blob;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(Blob.class)
+public class BlobTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Blob#getBinaryStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBinaryStream",
+      args = {}
+      )
+    public void testGetBinaryStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#getBytes(long, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBytes",
+      args = {long.class, int.class}
+      )
+    public void testGetBytes() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#length()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "length",
+      args = {}
+      )
+    public void testLength() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#position(java.sql.Blob, long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "position",
+      args = {Blob.class, long.class}
+      )
+    public void testPositionBlobLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#position(byte[], long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method =  "position",
+      args = {byte[].class, long.class}
+    )
+    public void testPositionByteArrayLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#setBinaryStream(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBinaryStream",
+      args = {long.class}
+      )
+    public void testSetBinaryStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#setBytes(long, byte[])}.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method  = "setBytes",
+            args = {long.class, byte[].class}
+    )
+    public void testSetBytesLongByteArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#setBytes(long, byte[], int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBytes",
+      args = {long.class, byte[].class, int.class, int.class}
+      )
+    public void testSetBytesLongByteArrayIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Blob#truncate(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "truncate",
+      args = {long.class}
+      )
+    public void testTruncate() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/CallableStatementTest.java b/sql/src/test/java/tests/sql/CallableStatementTest.java
new file mode 100644
index 0000000..db7aca1
--- /dev/null
+++ b/sql/src/test/java/tests/sql/CallableStatementTest.java
@@ -0,0 +1,1070 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.CallableStatement;
+import java.sql.Date;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Calendar;
+import java.util.Map;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(CallableStatement.class)
+public class CallableStatementTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getArray(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getArray",
+          args = {int.class}
+      )
+    public void testGetArrayInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getArray(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getArray",
+      args = {String.class}
+    )
+    public void testGetArrayString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBigDecimal(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBigDecimal",
+      args = {int.class}
+    )
+    public void testGetBigDecimalInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBigDecimal(int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBigDecimal",
+      args = {int.class, int.class}
+    )
+    public void testGetBigDecimalIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBigDecimal(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBigDecimal",
+      args = {String.class}
+    )
+    public void testGetBigDecimalString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBlob(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBlob",
+      args = {int.class}
+    )
+    public void testGetBlobInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBlob(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBlob",
+      args = {String.class}
+    )
+    public void testGetBlobString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBoolean(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBoolean",
+      args = {int.class}
+    )
+    public void testGetBooleanInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBoolean(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBoolean",
+      args = {String.class}
+    )
+    public void testGetBooleanString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getByte(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getByte",
+      args = {int.class}
+    )
+    public void testGetByteInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getByte(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getByte",
+      args = {String.class}
+    )
+    public void testGetByteString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBytes(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBytes",
+      args = {int.class}
+    )
+    public void testGetBytesInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getBytes(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBytes",
+      args = {String.class}
+    )
+    public void testGetBytesString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getClob(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getClob",
+      args = {int.class}
+    )
+    public void testGetClobInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getClob(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getClob",
+      args = {String.class}
+    )
+    public void testGetClobString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDate(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDate",
+      args = {int.class}
+    )
+    public void testGetDateInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDate(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDate",
+      args = {int.class, Calendar.class}
+    )
+    public void testGetDateIntCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDate(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDate",
+      args = {String.class}
+    )
+    public void testGetDateString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDate(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDate",
+      args = {String.class, Calendar.class}
+    )
+    public void testGetDateStringCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDouble(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDouble",
+      args = {int.class}
+    )
+    public void testGetDoubleInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getDouble(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getDouble",
+      args = {String.class}
+    )
+    public void testGetDoubleString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getFloat(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getFloat",
+      args = {int.class}
+    )
+    public void testGetFloatInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getFloat(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getFloat",
+      args = {String.class}
+    )
+    public void testGetFloatString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getInt(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getInt",
+      args = {int.class}
+    )
+    public void testGetIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getInt(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getInt",
+      args = {String.class}
+    )
+    public void testGetIntString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getLong(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getLong",
+      args = {int.class}
+    )
+    public void testGetLongInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getLong(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getLong",
+      args = {String.class}
+    )
+    public void testGetLongString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getObject(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {int.class}
+    )
+    public void testGetObjectInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getObject(int, java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {int.class, Map.class}
+    )
+    public void testGetObjectIntMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getObject(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {String.class}
+    )
+    public void testGetObjectString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getObject(java.lang.String, java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {String.class, Map.class}
+    )
+    public void testGetObjectStringMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getRef(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getRef",
+      args = {int.class}
+    )
+    public void testGetRefInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getRef(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getRef",
+      args = {String.class}
+    )
+    public void testGetRefString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getShort(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getShort",
+      args = {int.class}
+    )
+    public void testGetShortInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getShort(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getShort",
+      args = {String.class}
+    )
+    public void testGetShortString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getString(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getString",
+      args = {int.class}
+    )
+    public void testGetStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getString(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getString",
+      args = {String.class}
+    )
+    public void testGetStringString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTime(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTime",
+      args = {int.class}
+    )
+    public void testGetTimeInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTime(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTime",
+      args = {int.class, Calendar.class}
+    )
+    public void testGetTimeIntCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTime(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTime",
+      args = {String.class}
+    )
+    public void testGetTimeString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTime(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTime",
+      args = {String.class, Calendar.class}
+    )
+    public void testGetTimeStringCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTimestamp(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTimestamp",
+      args = {int.class}
+    )
+    public void testGetTimestampInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTimestamp(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTimestamp",
+      args = {int.class, Calendar.class}
+    )
+    public void testGetTimestampIntCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTimestamp(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTimestamp",
+      args = {String.class}
+    )
+    public void testGetTimestampString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getTimestamp(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getTimestamp",
+      args = {String.class, Calendar.class}
+    )
+    public void testGetTimestampStringCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getURL(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getURL",
+      args = {int.class}
+    )
+    public void testGetURLInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#getURL(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getURL",
+      args = {String.class}
+    )
+    public void testGetURLString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {int.class, int.class}
+    )
+    public void testRegisterOutParameterIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {int.class, int.class, int.class}
+    )
+    public void testRegisterOutParameterIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(int, int, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {int.class, int.class, String.class}
+    )
+    public void testRegisterOutParameterIntIntString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {String.class, int.class}
+    )
+    public void testRegisterOutParameterStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {String.class, int.class, int.class}
+    )
+    public void testRegisterOutParameterStringIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#registerOutParameter(java.lang.String, int, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "registerOutParameter",
+      args = {String.class, int.class, String.class}
+    )
+    public void testRegisterOutParameterStringIntString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setAsciiStream(java.lang.String, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setAsciiStream",
+      args = {String.class, InputStream.class, int.class}
+    )
+    public void testSetAsciiStreamStringInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setBigDecimal(java.lang.String, java.math.BigDecimal)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBigDecimal",
+      args = {String.class, BigDecimal.class}
+    )
+    public void testSetBigDecimalStringBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setBinaryStream(java.lang.String, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBinaryStream",
+      args = {String.class, InputStream.class, int.class}
+    )
+    public void testSetBinaryStreamStringInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setBoolean(java.lang.String, boolean)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBoolean",
+      args = {String.class, boolean.class}
+    )
+    public void testSetBooleanStringBoolean() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setByte(java.lang.String, byte)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setByte",
+      args = {String.class, byte.class}
+    )
+    public void testSetByteStringByte() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setBytes(java.lang.String, byte[])}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setBytes",
+      args = {String.class, byte[].class}
+    )
+    public void testSetBytesStringByteArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setCharacterStream(java.lang.String, java.io.Reader, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setCharacterStream",
+      args = {String.class, Reader.class, int.class}
+    )
+    public void testSetCharacterStreamStringReaderInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setDate",
+      args = {String.class, Date.class}
+    )
+    public void testSetDateStringDate() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setDate(java.lang.String, java.sql.Date, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setDate",
+      args = {String.class, Date.class, Calendar.class}
+    )
+    public void testSetDateStringDateCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setDouble(java.lang.String, double)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setDouble",
+      args = {String.class, double.class}
+    )
+    public void testSetDoubleStringDouble() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setFloat(java.lang.String, float)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setFloat",
+      args = {String.class, float.class}
+    )
+    public void testSetFloatStringFloat() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setInt(java.lang.String, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setInt",
+      args = {String.class, int.class}
+    )
+    public void testSetIntStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setLong(java.lang.String, long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setLong",
+      args = {String.class, long.class}
+    )
+    public void testSetLongStringLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setNull(java.lang.String, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setNull",
+      args = {String.class, int.class}
+    )
+    public void testSetNullStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setNull(java.lang.String, int, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setNull",
+      args = {String.class, int.class, String.class}
+    )
+    public void testSetNullStringIntString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setObject",
+      args = {String.class, Object.class}
+    )
+    public void testSetObjectStringObject() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setObject",
+      args = {String.class, Object.class, int.class}
+    )
+    public void testSetObjectStringObjectInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setObject(java.lang.String, java.lang.Object, int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setObject",
+      args = {String.class, Object.class, int.class, int.class}
+    )
+    public void testSetObjectStringObjectIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setShort(java.lang.String, short)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setShort",
+      args = {String.class, short.class}
+    )
+    public void testSetShortStringShort() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setString(java.lang.String, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setString",
+      args = {String.class, String.class}
+    )
+    public void testSetStringStringString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setTime",
+      args = {String.class, Time.class}
+    )
+    public void testSetTimeStringTime() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setTime(java.lang.String, java.sql.Time, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setTime",
+      args = {String.class, Time.class, Calendar.class}
+    )
+    public void testSetTimeStringTimeCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setTimestamp",
+      args = {String.class, Timestamp.class}
+    )
+    public void testSetTimestampStringTimestamp() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setTimestamp(java.lang.String, java.sql.Timestamp, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setTimestamp",
+      args = {String.class, Timestamp.class, Calendar.class}
+    )
+    public void testSetTimestampStringTimestampCalendar() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#setURL(java.lang.String, java.net.URL)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "setURL",
+      args = {String.class, URL.class}
+    )
+    public void testSetURLStringURL() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.CallableStatement#wasNull()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "wasNull",
+      args = {}
+    )
+    public void testWasNull() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/ClobTest.java b/sql/src/test/java/tests/sql/ClobTest.java
new file mode 100644
index 0000000..c0f218f
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ClobTest.java
@@ -0,0 +1,177 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Clob;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(Clob.class)
+public class ClobTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Clob#getAsciiStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getAsciiStream",
+          args = {}
+      )
+    public void testGetAsciiStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#getCharacterStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getCharacterStream",
+          args = {}
+      )
+    public void testGetCharacterStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#getSubString(long, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getSubString",
+          args = {long.class, int.class}
+      )
+    public void testGetSubString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#length()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "length",
+          args = {}
+      )
+    public void testLength() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#position(java.sql.Clob, long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "position",
+          args = {Clob.class, long.class}
+      )
+    public void testPositionClobLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#position(java.lang.String, long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "position",
+          args = {String.class, long.class}
+      )
+    public void testPositionStringLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#setAsciiStream(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "setAsciiStream",
+          args = {long.class}
+      )
+    public void testSetAsciiStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#setCharacterStream(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "setCharacterStream",
+          args = {long.class}
+      )
+    public void testSetCharacterStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#setString(long, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "setString",
+          args = {long.class, String.class}
+      )
+    public void testSetStringLongString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#setString(long, java.lang.String, int, int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "setString",
+          args = {long.class, String.class, int.class, int.class}
+      )
+    public void testSetStringLongStringIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Clob#truncate(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "truncate",
+          args = {long.class}
+      )
+    public void testTruncate() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/ConnectionTest.java b/sql/src/test/java/tests/sql/ConnectionTest.java
new file mode 100755
index 0000000..1bf2ff6
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ConnectionTest.java
@@ -0,0 +1,2817 @@
+/*
+ * 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.sql.Connection;
+import java.sql.DatabaseMetaData;
+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() {
+        try {
+            assertFalse(conn.isClosed());
+            conn.close();
+            assertTrue(conn.isClosed());
+        } catch (SQLException e) {
+            fail("Error in implementation");
+            e.printStackTrace();
+        }
+        
+        try {
+            this.setUp();
+            assertFalse(conn.isClosed());
+            Statement st = conn.createStatement();
+            st.execute("select * from zoo");
+        } catch (SQLException e2) {
+            fail("Error in test setup");
+        }
+    }
+    
+
+    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";
+        }
+        
+    }
+}
diff --git a/sql/src/test/java/tests/sql/ParameterMetaDataTest.java b/sql/src/test/java/tests/sql/ParameterMetaDataTest.java
new file mode 100644
index 0000000..f522450
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ParameterMetaDataTest.java
@@ -0,0 +1,150 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.ParameterMetaData;
+
+/**
+ *
+ */
+@TestTargetClass(ParameterMetaData.class)
+public class ParameterMetaDataTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getParameterClassName(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getParameterClassName",
+          args = {int.class}
+    )
+    public void testGetParameterClassName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getParameterCount()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getParameterCount",
+          args = {}
+      )
+    public void testGetParameterCount() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getParameterMode(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getParameterMode",
+          args = {int.class}
+      )
+    public void testGetParameterMode() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getParameterType(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getParameterType",
+          args = {int.class}
+      )
+    public void testGetParameterType() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getParameterTypeName(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getParameterTypeName",
+          args = {int.class}
+      )
+    public void testGetParameterTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getPrecision(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getPrecision",
+          args = {int.class}
+      )
+    public void testGetPrecision() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#getScale(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getScale",
+          args = {int.class}
+      )
+    public void testGetScale() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#isNullable(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "isNullable",
+          args = {int.class}
+      )
+    public void testIsNullable() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ParameterMetaData#isSigned(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "isSigned",
+          args = {int.class}
+      )
+    public void testIsSigned() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/PreparedStatementTest.java b/sql/src/test/java/tests/sql/PreparedStatementTest.java
new file mode 100755
index 0000000..68d5117
--- /dev/null
+++ b/sql/src/test/java/tests/sql/PreparedStatementTest.java
@@ -0,0 +1,3250 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * 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.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.Reader;
+import java.io.Writer;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.ParameterMetaData;
+import java.sql.PreparedStatement;
+import java.sql.Ref;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.sql.Types;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Locale;
+import java.util.Map;
+import java.util.TimeZone;
+
+@TestTargetClass(PreparedStatement.class)
+public class PreparedStatementTest extends SQLTest {
+
+    String queryAllSelect = "select * from type";
+
+    String[] queries = {
+            "create table type (" +
+
+            " BoolVal BOOLEAN," + " IntVal INT," + " LongVal LONG,"
+                    + " Bint BIGINT," + " Tint TINYINT," + " Sint SMALLINT,"
+                    + " Mint MEDIUMINT, " +
+
+                    " IntegerVal INTEGER, " + " RealVal REAL, "
+                    + " DoubleVal DOUBLE, " + " FloatVal FLOAT, "
+                    + " DecVal DECIMAL, " +
+
+                    " NumVal NUMERIC, " + " charStr CHAR(20), "
+                    + " dateVal DATE, " + " timeVal TIME, " + " TS TIMESTAMP, "
+                    +
+
+                    " DT DATETIME, " + " TBlob TINYBLOB, " + " BlobVal BLOB, "
+                    + " MBlob MEDIUMBLOB, " + " LBlob LONGBLOB, " +
+
+                    " TText TINYTEXT, " + " TextVal TEXT, "
+                    + " MText MEDIUMTEXT, " + " LText LONGTEXT " + ");",
+
+            "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,"
+                    + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal,"
+                    + "NumVal, charStr, dateVal, timeVal, TS,"
+                    + "DT, TBlob, BlobVal, MBlob, LBlob,"
+                    + "TText, TextVal, MText, LText"
+                    + ") "
+                    + "values (1, -1, 22, 2, 33,"
+                    + "3, 1, 2, 3.9, 23.2, 33.3, 44,"
+                    + "5, 'test string', '1799-05-26', '12:35:45', '2007-10-09 14:28:02.0',"
+                    + "'1221-09-22 10:11:55', 1, 2, 3, 4,"
+                    + "'Test text message tiny', 'Test text message', 'Test text message medium', 'Test text message long');" };
+
+    public void setUp() {
+        super.setUp();
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i]);
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.toString());
+        } finally {
+            try {
+                st.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    public void tearDown() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.execute("drop table if exists type");
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        super.tearDown();
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#addBatch()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "addBatch",
+        args = {}
+    )
+    public void testAddBatch() throws SQLException {
+        PreparedStatement ps = null;
+        try {
+            ps = conn
+                    .prepareStatement("INSERT INTO zoo VALUES (3,'Tuzik', ?);");
+            ps.addBatch("INSERT INTO zoo VALUES (?,'Burenka', ?); ");
+            ps.addBatch("INSERT INTO zoo VALUES (?,'Mashka','cat')");
+            try {
+                ps.executeBatch();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown for executeBatch()");
+            }
+            ps.setString(1, "dog");
+            Statement st = null;
+            try {
+                ps.executeBatch();
+                st = conn.createStatement();
+                st.execute("select * from zoo");
+                ResultSet rs = st.getResultSet();
+                assertEquals(2, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown for executeBatch()");
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown "+e.getMessage());
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            ps = conn
+                    .prepareStatement("INSERT INTO zoo VALUES (3,'Tuzik', ?);");
+            ps.addBatch("");
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            ps = conn
+                    .prepareStatement("INSERT INTO zoo VALUES (3,'Tuzik', ?);");
+            ps.addBatch(null);
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+   
+    /**
+     * @test java.sql.PreparedStatement#execute()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "execute",
+        args = {}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testExecute() {
+        Statement st = null;
+        PreparedStatement ps = null;
+        try {
+            //update
+            String query = "insert into zoo(id, family, name) values(?, ?, 'unknown animal')";
+            ps = conn.prepareStatement(query);
+            ps.setInt(1, 3);
+            ps.setString(2, "No name");
+            assertFalse(ps.execute());
+            assertEquals(1,ps.getUpdateCount());
+            
+            // select
+            ps = conn.prepareStatement("select * from zoo");
+            assertTrue(ps.execute());
+            assertEquals(3, getCount(ps.getResultSet()));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+
+        try {
+            String query = "update zoo set name='Masha', family=? where id=?;";
+            ps = conn.prepareStatement(query);
+            ps.setString(1, "cat");
+            ps.setInt(2, 2);
+            assertFalse(ps.execute());
+            assertEquals(1, ps.getUpdateCount());
+            st = conn.createStatement();
+            st.execute("select family from zoo where id=2");
+            ResultSet rs = st.getResultSet();
+            rs.next();
+            assertEquals("cat", rs.getString(1));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                ps.close();
+                st.close();
+            } catch (Exception ee) {
+            }
+        }
+
+        try {
+            conn.createStatement().execute("drop table if exists hutch");
+            String query = "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));";
+            ps = conn.prepareStatement(query);
+            assertFalse(ps.execute());
+            assertTrue(ps.getUpdateCount() > 0);
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+
+        try {
+            String query = "select name, family from zoo where id = ?";
+            ps = conn.prepareStatement(query);
+            ps.setInt(1, 1);
+            assertTrue(ps.execute());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+
+        try {
+            String query = "select name, family from zoo where id = ?";
+            ps = conn.prepareStatement(query);
+            ps.execute();
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+        //Exception test
+        try {
+            String query = "update zoo set name='Masha', family=? where id=?;";
+            ps = conn.prepareStatement(query);
+            ps.setString(1, "cat");
+            ps.setInt(2, 2);
+            assertTrue(ps.execute("update zoo set name='Masha', family='cat' where id=2;"));
+        } catch (SQLException e) {
+            // ok Should not provide string argument for a prepared Statement
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+     
+   
+    /**
+     * @test java.sql.PreparedStatement#executeQuery()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "executeQuery",
+        args = {}
+    )
+      public void testExecuteQuery() {
+
+        String[] queries2 = {
+                "update zoo set name='Masha', family='cat' where id=;",
+                "insert into hutch (id, animal_id, address) values (1, ?,'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (?, 1, 'Horse-house, 5');",
+                "create view address as select address from hutch where animal_id=?"};
+
+        for (int i = 0; i < queries2.length; i++) {
+            PreparedStatement ps = null;
+            try {
+                ps = conn.prepareStatement(queries2[i]);
+                ps.executeQuery();
+                fail("SQLException is not thrown for query: " + queries2[i]);
+            } catch (SQLException sqle) {
+                // expected
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+        }
+
+        String query = "select * from zoo where id = ?";
+        PreparedStatement ps = null;
+        try {
+            ps = conn.prepareStatement(query);
+            ps.setInt(1, 1);
+            ResultSet rs = ps.executeQuery();
+            rs.next();
+            assertEquals(1, rs.getInt(1));
+            assertEquals("Kesha", rs.getString(2));
+            assertEquals("parrot", rs.getString(3));
+        } catch (SQLException e) {
+            fail("SQLException is thrown for query");
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+
+        try {
+            ps = conn.prepareStatement(query);
+            ps.setInt(1, 5);
+            ResultSet rs = ps.executeQuery();
+            assertNotNull(rs);
+            assertFalse(rs.next());
+        } catch (SQLException e) {
+            fail("SQLException is thrown for query");
+        } finally {
+            try {
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+     
+     // TODO Crashes VM. Fix later.
+    /**
+     * @test {@link java.sql.PreparedStatement#executeUpdate()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "executeUpdate",
+        args = {}
+    )
+      public void testExecuteUpdate() { 
+          String[] queries1 = { "insert into hutch (id, animal_id, address) values (1, ?, 'Birds-house, 1');", 
+                              "insert into hutch (id, animal_id, address) values (?, 1, 'Horse-house, 5');",
+                              "create view address as select address from hutch where animal_id=2" };
+      
+          for (int i = 0; i < queries1.length; i++) { 
+              PreparedStatement ps = null;
+              try { 
+                  ps = conn.prepareStatement(queries1[i]); 
+                  ps.executeUpdate();
+                  fail("SQLException is not thrown for query: " + queries1[i]); 
+          } catch(SQLException sqle) { 
+              // expected 
+          } finally { 
+              try { 
+                  ps.close(); 
+              } catch(Exception ee) {} 
+          } 
+      } 
+      
+          String query = "update zoo set name='Masha', family='cat' where id=?;"; 
+          PreparedStatement ps = null; 
+          try {
+              ps = conn.prepareStatement(query); 
+              ps.setInt(1, 2); 
+              int updateCount = ps.executeUpdate(); 
+              assertEquals(1, updateCount); 
+              ps.setInt(1, 1); 
+              int updateCount1 = ps.executeUpdate(); 
+              assertEquals(1, updateCount1); 
+          } catch (SQLException e) { 
+              fail("SQLException is thrown for query"); 
+          } finally {
+              try { 
+                  ps.close(); 
+              } catch(Exception ee) {} 
+          } 
+      }
+      
+    /**
+     * @test java.sql.PreparedStatement#getMetaData()
+     *  
+     *  Test Fails:
+     * TODO Doesn't pass. according to Java docs:
+     * it is possible to invoke the method getMetaData on a 
+     * PreparedStatement object before it is executed.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getMetaData",
+        args = {}
+    )
+    @KnownFailure("it is not possible to invoke the method getMetaData on a " + 
+                  "PreparedStatement object before it is executed: got NullPointerException."+
+                  "Test passes on RI.")
+    public void testGetMetaData() {
+        PreparedStatement ps = null;
+        
+        // Specification testing
+        
+        try {
+            String query = "update zoo set name='Masha', family='cat' where id=?;";
+            ps = conn.prepareStatement(query);
+            assertNotNull(ps);
+            ResultSetMetaData meta = ps.getMetaData();
+            assertNotNull(meta);
+        } catch (SQLException sqle) {
+            fail("SQLException is thrown: " + sqle.toString());
+            sqle.printStackTrace();
+        } catch (Exception e) {
+            fail("Unspecified Exception: " + e.toString());
+            e.printStackTrace();
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            String query = "select * from zoo where id = ?";
+            ps = conn.prepareStatement(query);
+            ResultSetMetaData rsmd = ps.getMetaData();
+            assertNotNull(rsmd);
+            assertEquals(3, rsmd.getColumnCount());
+            assertEquals("id", rsmd.getColumnName(1));
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        // ps closed
+        try {
+            ps.getMetaData();
+            fail("SQLException expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * @throws SQLException 
+     * @test java.sql.PreparedStatement#getParameterMetaData()
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getParameterMetaData",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void testGetParameterMetaData() throws SQLException {
+        PreparedStatement ps = null;
+        String query = "select * from zoo where id = ?";
+        ps = conn.prepareStatement(query);
+        
+        try {
+            ParameterMetaData rsmd = ps.getParameterMetaData();
+        } catch (SQLException e) {
+            assertEquals("not supported",e.getMessage());
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        ps.close();
+     
+        try {
+            ps.getParameterMetaData();
+            fail("SQLException expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+    
+    
+    /**
+     * @test java.sql.PreparedStatement#clearParameters()
+     * Test fails: clearparameters should be implemented with Stmt.reset()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Test fails: clearparameters should be implemented with Stmt.reset()",
+        method = "clearParameters",
+        args = {}
+    )
+    @KnownFailure("First Exception test fails: parameters not cleared.")
+     public void testClearParameters() {
+        PreparedStatement ps = null;
+        try {
+            String query = "select * from zoo where id = ? and family=?";
+            ps = conn.prepareStatement(query);
+            ps.clearParameters();
+            try {
+                ps.execute();
+                fail("SQLException is not thrown during execute method after calling clearParameters()");
+            } catch (SQLException sql) {
+                
+            }
+            ps.setInt(1, 2);
+            ps.setString(2, "dog");
+            ps.clearParameters();
+            try {
+                ps.execute();
+                fail("SQLException is not thrown during execute method after calling clearParameters()");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            ps.setInt(1, 2);
+            ps.clearParameters();
+            try {
+                ps.execute();
+                fail("SQLException is not thrown during execute method after calling clearParameters()");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            ps.setInt(1, 2);
+            ps.setString(2, "cat");
+
+            try {
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown during execute method after calling clearParameters() twice");
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+    }
+     
+    /**
+     * @test java.sql.PreparedStatement#setInt(int parameterIndex, int x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setInt",
+        args = {int.class, int.class}
+    )
+    public void testSetInt() throws SQLException {
+        
+        PreparedStatement ps = null;
+        Statement st = null;
+        try {
+            String query = "insert into type (IntVal) values (?);";
+            ps = conn.prepareStatement(query);
+            try {
+                ps.setInt(1, Integer.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where IntVal="
+                        + Integer.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            ps = conn.prepareStatement(query);
+            try {
+                ps.setInt(1, Integer.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where IntVal="
+                        + Integer.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+            ps = conn.prepareStatement(query);
+            ps.close();
+            try {
+                ps.setInt(1, Integer.MIN_VALUE);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setLong(int parameterIndex, long x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setLong",
+        args = {int.class, long.class}
+    )
+    public void testSetLong() {
+        
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (LongVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setLong(1, Long.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where LongVal="
+                                + Long.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setLong(1, Long.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where LongVal="
+                                + Long.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+            
+            ps.close();
+            try {
+                ps.setLong(1, Long.MIN_VALUE);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+    }
+
+    /**
+     * @throws SQLException 
+     * @test java.sql.PreparedStatement#setFloat(int parameterIndex, float x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setFloat",
+        args = {int.class, float.class}
+    )
+    public void testSetFloat() throws SQLException {
+        float value1 = 12345678.12345689f;
+        float value2 = -12345678.12345689f;
+        
+        PreparedStatement ps = null;
+        String query = "insert into type (FloatVal) values (?);";
+        ps = conn.prepareStatement(query);
+        
+        try {
+            
+            Statement st = null;
+            try {
+                ps.setFloat(1, value1);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where FloatVal=" + value1);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setFloat(1, value2);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where FloatVal=" + value2);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                    
+                }
+            }
+            ps.close();
+            try {
+                ps.setFloat(1, Float.MIN_VALUE);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @throws SQLException 
+     * @test java.sql.PreparedStatement#setDouble(int parameterIndex, double x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setDouble",
+        args = {int.class, double.class}
+    )
+    public void testSetDouble() throws SQLException {
+        
+        PreparedStatement ps = null;
+        String query = "insert into type (DoubleVal) values (?);";
+        ps = conn.prepareStatement(query);
+        
+        try {
+            
+            Statement st = null;
+            try {
+                ps.setDouble(1, Double.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where DoubleVal="
+                        + Double.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setDouble(1, Double.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where DoubleVal="
+                        + Double.MIN_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+            
+            ps.close();
+            try {
+                ps.setDouble(1, 2.0);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetString_charField() {
+        
+        PreparedStatement ps = null;
+        
+        try {
+            String query = "insert into type (charStr) values (?);";
+            ps = conn.prepareStatement(query);
+            
+            String str = "test^text$test%";
+            Statement st = null;
+            try {
+                ps.setString(1, str);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where charStr='" + str + "'");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where charStr=''");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "                   ");
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where charStr='                   '");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+            
+            try {
+                ps.setString(1, " test & text * test % text * test ^ text ");
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+
+            try {
+                ps.setString(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+            
+            ps.close();
+            
+            try {
+                ps.setString(1, "test text");
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testSetString_tinyTextField() {
+        
+        PreparedStatement ps = null;
+        try {
+            String str = "test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test";
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setString(1, str);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where TText='" + str + "'");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where TText=''");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "                   ");
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where TText='                   '");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+            
+            try {
+                ps.setString(
+                                1,
+                                "test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test*test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test-test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test+test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test?test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test#test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test ");
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+
+            try {
+                ps.setString(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+            
+            ps.close();
+
+            try {
+                ps.setString(1, "test text");
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetString_textField() {
+        
+        PreparedStatement ps = null;
+        try {
+            String str = "test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test";
+            String query = "insert into type (TextVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setString(1, str);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where TextVal='" + str + "'");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where TextVal=''");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "                   ");
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where TextVal='                   '");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+
+            try {
+                String longString = " test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/";
+                for (int i = 0; i < 10; i++) {
+                    longString += longString;
+                }
+                ps.setString(1, longString);
+                ps.execute();
+ 
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+
+            try {
+                ps.setString(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+            
+            ps.close();
+            
+            try {
+                ps.setString(2, "test text");
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetString_mediumTextField() {
+        
+        PreparedStatement ps = null;
+        try {
+            String str = "test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test";
+            String query = "insert into type (MText) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setString(1, str);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where MText='" + str + "'");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where MText=''");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "                   ");
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where MText='                   '");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+            try {
+                ps.setString(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+            
+            ps.close();
+
+            try {
+                ps.setString(2, "test text");
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setString",
+        args = {int.class, java.lang.String.class}
+    )
+    public void testSetString_longTextField() {
+        
+        PreparedStatement ps = null;
+        try {
+            String str = "test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test/test^text$test%test(text)test@text5test~test^text$test%test(text)test@text5test";
+            String query = "insert into type (LText) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setString(1, str);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where LText='" + str + "'");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where LText=''");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setString(1, "                   ");
+                ps.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where LText='                   '");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+            try {
+                ps.setString(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+            
+            ps.close();
+
+            try {
+                ps.setString(1, "test text");
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setShort(int parameterIndex, short x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setShort",
+        args = {int.class, short.class}
+    )
+    public void testSetShort() {
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        PreparedStatement ps2 = null;
+        try {
+            String query = "insert into type (Sint) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setShort(1, Short.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where Sint=" + Short.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setShort(1, Short.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where Sint=" + Short.MIN_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+            ps.close();
+
+            try {
+                ps.setShort(1, Short.MIN_VALUE);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+            try {
+                ps1.setShort(1, Short.MAX_VALUE);
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: "+sqle.getMessage());
+            }
+
+            String query2 = "insert into type (IntVal) values (?);";
+            ps2 = conn.prepareStatement(query2);
+            try {
+                ps2.setShort(1, Short.MAX_VALUE);
+                ps2.execute();
+                st = conn.createStatement();
+                st
+                        .execute("select * from type where IntVal="
+                                + Short.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+                ps2.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setBoolean(int parameterIndex, boolean
+     *       x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setBoolean",
+        args = {int.class, boolean.class}
+    )
+    public void testSetBoolean() {
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (BoolVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setBoolean(1, false);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where BoolVal = 0");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            try {
+                ps.setBoolean(1, true);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where BoolVal= 1");
+                ResultSet rs = st.getResultSet();
+                assertEquals(2, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+            ps.close();
+
+            try {
+                ps.setBoolean(1, false);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+            try {
+                ps1.setBoolean(1, true);
+                ps1.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setByte(int parameterIndex, byte x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setByte",
+        args = {int.class, byte.class}
+    )
+    public void testSetByte() {
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (Tint) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setByte(1, Byte.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where Tint=" + Byte.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            try {
+                ps.setByte(1, Byte.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where Tint=" + Byte.MIN_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            try {
+                ps.setByte(2, Byte.MAX_VALUE);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            
+            ps.close();
+
+            try {
+                ps.setByte(1, Byte.MIN_VALUE);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            String query1 = "insert into type (IntVal) values (?);";
+            ps1 = conn.prepareStatement(query1);
+            try {
+                ps1.setByte(1, Byte.MAX_VALUE);
+                ps1.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setBytes(int parameterIndex, byte[] x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setBytes",
+        args = {int.class, byte[].class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testSetBytes() {
+
+        byte[] bytesArray = {1, 0};
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (LBlob) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setBytes(1, bytesArray);
+                assertFalse(ps.execute());
+                assertTrue(ps.getUpdateCount() > 0);
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } 
+
+            try {
+                ps.setBytes(2, bytesArray);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected RuntimeException or SQLException
+            }
+            
+            ps.close();
+
+            try {
+                ps.setBytes(1, bytesArray);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            String query1 = "insert into type (TBlob) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps.setBytes(1, bytesArray);
+                assertFalse(ps.execute());
+                assertTrue(ps.getUpdateCount() > 0);
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } 
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                if (ps != null) ps.close();
+                if (ps1 != null) ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setBigDecimal(int parameterIndex,
+     *       BigDecimal x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setBigDecimal",
+        args = {int.class, java.math.BigDecimal.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testSetBigDecimal() {
+
+        BigDecimal bd = new BigDecimal("50");
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (DecVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setBigDecimal(1, bd);
+                assertFalse(ps.execute());
+                assertTrue(ps.getUpdateCount() > 0);
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } 
+            
+
+            try {
+                ps.setBigDecimal(2, bd);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+                assertEquals("bad parameter index", sqle.getMessage());
+            }
+
+            try {
+                ps.setBigDecimal(-2, bd);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+                assertEquals("bad parameter index", sqle.getMessage());
+            }
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setBigDecimal(1, bd);
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                if (ps != null) ps.close();
+                if (ps1 != null) ps1.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setDate(int parameterIndex, Date x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "First exception test fails: integer and date are incompatible"
+               +" by spec.",
+        method = "setDate",
+        args = {int.class, java.sql.Date.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update. "+
+            "Setting a data for a declared INTEGER should throw Exception")
+    public void testSetDate_int_Date() {
+        Calendar cal = new GregorianCalendar(1799, 5, 26);
+
+        Date[] dates = {
+                new Date(cal.getTimeInMillis()), new Date(Integer.MAX_VALUE),
+                new Date(123456789)};
+
+
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (dateVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            for (int i = 0; i < dates.length; i++) {
+                try {
+                    ps.setDate(1, dates[i]);
+                    assertFalse(ps.execute());
+                    assertTrue(ps.getUpdateCount() > 0);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+
+            try {
+                ps.setDate(2, dates[0]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+
+            ps.close();
+
+            try {
+                ps.setDate(1, dates[0]);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setDate(1, dates[0]);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+                assertEquals("SQLite.Exception: error in prepare", sqle
+                        .getMessage());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+
+                if (ps != null) ps.close();
+                if (ps1 != null) ps1.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setDate(int parameterIndex, Date x,
+     *       Calendar cal)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setDate",
+        args = {int.class, java.sql.Date.class, java.util.Calendar.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testSetDate_int_Date_Calendar() {
+
+        Calendar[] cals = { Calendar.getInstance(),
+                Calendar.getInstance(Locale.GERMANY),
+                Calendar.getInstance(TimeZone.getDefault()) };
+        Calendar cal = new GregorianCalendar(1799,5,26);
+
+        Date[] dates = { new Date(cal.getTimeInMillis()), new Date(Integer.MAX_VALUE),
+                new Date(123456789) };
+
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (dateVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            for (int i = 0; i < dates.length; i++) {
+                
+                try {
+                    ps.setDate(1, dates[i], cals[i]);
+                    assertFalse(ps.execute());
+                    assertTrue(ps.getUpdateCount() > 0);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+
+            try {
+                ps.setDate(2, dates[0], cals[0]);
+                ps.execute();
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            
+            ps.close();
+            
+            try {
+                ps.setDate(1, dates[0], cals[1]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setDate(1, dates[0], cals[2]);
+                ps1.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                if (ps != null) ps.close();
+                if (ps1 != null) ps1.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setNull(int parameterIndex, int sqlType)
+     * 
+     * this test doesn't passed on RI
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setNull",
+        args = {int.class, int.class}
+    )
+    public void testSetNull_int_int() {
+        
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (BoolVal, IntVal) values ('true', ?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setNull(1, Types.INTEGER);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (BoolVal, LongVal) values ('true', ?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setNull(1, Types.BIGINT);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (BoolVal, DecVal) values ('true', ?)";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setNull(1, Types.DECIMAL);
+                ps.execute();
+             } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (BoolVal, dateVal) values ('true', ?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setNull(1, Types.DATE);
+                ps.execute();
+            } catch (SQLException sqle) {
+               fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (BoolVal, BlobVal) values ('true', ?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setNull(1, Types.BLOB);
+                ps.execute();
+            } catch (SQLException sqle) {
+               fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (BoolVal, TextVal) values ('true', ?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setNull(1, Types.CHAR);
+                ps.execute();
+            } catch (SQLException sqle) {
+               fail("SQLException is thrown: " + sqle.getMessage());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setNull(int, int, String)}
+     * 
+     * UDTs and Ref types not supported in SQLite v 3
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setNull",
+        args = {int.class, int.class, java.lang.String.class}
+    )
+    public void testSetNullIntintString() {
+        // test UDT
+        String typeCreationStmtUDT = "CREATE TYPE addressType AS "
+        +"( street INTEGER, zip TEXT);";
+        String personTableCreateUDT = "CREATE TABLE person (name TEXT, address addressType);";
+        Statement st = null;
+        PreparedStatement ps = null;
+        try {
+            st = conn.createStatement();
+            st.execute(typeCreationStmtUDT);
+            st.execute(personTableCreateUDT);
+            fail("UDTs and Ref Types not supported");
+            String query = "insert into person (name, address) values ('Hans', ?);";
+            ps = conn.prepareStatement(query);
+            try {
+                ps.setNull(1, Types.DATALINK);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+                sqle.printStackTrace();
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+        } catch (SQLException e) {
+         // UDTs or Ref types not supported
+           // ok
+        } finally {
+            try {
+                st.execute("drop table if exists person");
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+        
+        // test non UDT REF type Exception checking
+        String personTableCreate = "create table person (name TEXT, Address TEXT)";
+            try {
+                
+                st = conn.createStatement();
+                st.execute(personTableCreate);
+                String insert = "insert into person (name, address) values (?, '1600 Amphitheatre Mountain View');";
+                ps = conn.prepareStatement(insert);
+                try {
+                    ps.setNull(1,1, "");
+                    ps.execute();
+                } catch (SQLException sqle) {
+                    assertEquals("SQLite.Exception: error in step",sqle.getMessage());
+                } finally {
+                    try {
+                        st.close();
+                    } catch (Exception ee) {
+                    }
+                }
+                
+            } catch (SQLException e) {
+                fail("SQLException is thrown: " + e.getMessage());
+                e.printStackTrace();
+            } finally {
+                try {
+                    st.execute("drop table if exists person");
+                    ps.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+         // test non UDT REF type OK
+            
+            personTableCreate = "create table person (name TEXT, Address TEXT)";
+                try {
+                    
+                    st = conn.createStatement();
+                    st.execute("drop table if exists person");
+                    st.execute(personTableCreate);
+                    String insert = "insert into person (name, address) values (?, '1600 Amphitheatre Mountain View');";
+                    ps = conn.prepareStatement(insert);
+                    try {
+                        ps.setNull(1,1, "");
+                        ps.execute();
+                    } catch (SQLException sqle) {
+                        fail("SQLException is thrown: " + sqle.getMessage());
+                        sqle.printStackTrace();
+                    } finally {
+                        try {
+                            st.close();
+                        } catch (Exception ee) {
+                        }
+                    }
+                    
+                } catch (SQLException e) {
+                    fail("SQLException is thrown: " + e.getMessage());
+                    e.printStackTrace();
+                } finally {
+                    try {
+                        st.execute("drop table if exists person");
+                        ps.close();
+                    } catch (Exception ee) {
+                    }
+                }
+        
+        
+    }
+
+
+    /**
+     * @test java.sql.PreparedStatement#setObject(int parameterIndex, Object x)
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class}
+    )
+    public void testSetObject_int_Object() {
+        
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (IntVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setObject(1, Integer.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where IntVal="
+                        + Integer.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (LongVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, "test text");
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where LongVal='test text';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+            query = "insert into type (DecVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, new Object());
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown");
+            }
+
+            query = "insert into type (dateVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Date d = new Date(123456789);
+
+            try {
+                ps.setObject(1, d);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where dateVal='"
+                        + d.getTime() + "';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            // this sub test doesn't pass on RI
+            query = "insert into type (BlobVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, null);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+        try {
+            ps.setObject(1, "test text");
+            fail("Exception not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setObject(int parameterIndex, Object x,
+     *       int targetSqlType)
+     * 
+     * this test doesn't pass on RI
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class, int.class}
+    )
+    public void testSetObject_int_Object_int() {
+        
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (IntVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setObject(1, Integer.MAX_VALUE, Types.INTEGER);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where IntVal="
+                        + Integer.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (LongVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, "test text", Types.CHAR);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where LongVal='test text';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (DecVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, new Object(), Types.DECIMAL);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.toString());
+            }
+
+            query = "insert into type (dateVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Date d = new Date(123456789);
+            
+
+            try {
+                ps.setObject(1, d, Types.DATE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where dateVal='"
+                        + d.getTime() + "';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            // this sub test doesn't pass on RI
+            query = "insert into type (BlobVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, "", Types.BLOB);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+        
+        try {
+            ps.setObject(1, Integer.MAX_VALUE, Types.INTEGER);
+            fail("Exception not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+        
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setObject(int parameterIndex, Object x,
+     *       int targetSqlType, int scale)
+     * 
+     * this test doesn't pass on RI
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setObject",
+        args = {int.class, java.lang.Object.class, int.class, int.class}
+    )
+    public void testSetObject_int_Object_int_int() {
+        
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (IntVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            try {
+                ps.setObject(1, Integer.MAX_VALUE, Types.INTEGER,
+                        Integer.MAX_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where IntVal="
+                        + Integer.MAX_VALUE);
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (LongVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, "test text", Types.CHAR, Integer.MIN_VALUE);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where LongVal='test text';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            query = "insert into type (DecVal) values (?);";
+            ps = conn.prepareStatement(query);
+            BigDecimal bd2 = new BigDecimal("12.21");
+
+            try {
+                ps.setObject(1, bd2, Types.DECIMAL, 2);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            }
+
+            query = "insert into type (dateVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Date d = new Date(123456789);
+            try {
+                ps.setObject(1, d , Types.DATE, -1);
+                ps.execute();
+                st = conn.createStatement();
+                st.execute("select * from type where dateVal='"
+                        + d.getTime() + "';");
+                ResultSet rs = st.getResultSet();
+                assertEquals(1, getCount(rs));
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+            // this sub test doesn't pass on RI
+            query = "insert into type(BlobVal) values (?);";
+            ps = conn.prepareStatement(query);
+
+            try {
+                ps.setObject(1, "", Types.BLOB, 0);
+                ps.execute();
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+            } catch (Exception ee) {
+            }
+        }
+        
+        try {
+            ps.setObject(1, "test text", Types.CHAR, Integer.MIN_VALUE);
+            fail("Exception not thrown");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setTime(int parameterIndex, Time x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTime",
+        args = {int.class, java.sql.Time.class}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testSetTimeint_Time() {
+
+        Time[] times = { new Time(24, 25, 26), new Time(Integer.MAX_VALUE),
+                new Time(123456789) };
+
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (timeVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            for (int i = 0; i < times.length; i++) {
+                try {
+                    ps.setTime(1, times[i]);
+                    ps.execute();
+                    st = conn.createStatement();
+                    st.execute("select * from type where timeVal='"
+                            + times[i].getTime() + "'");
+                    ResultSet rs = st.getResultSet();
+                    assertEquals(1, getCount(rs));
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                } finally {
+                    try {
+                        st.close();
+                    } catch (Exception ee) {
+                    }
+                }
+            }
+
+            try {
+                ps.setTime(2, times[0]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected index out of bounds
+            }
+            
+            ps.close();
+            
+            try {
+                ps.setTime(1, times[0]);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            String query1 = "insert into type (Tint) values (?)";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setTime(1, times[0]);
+                ps1.execute();
+
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.toString());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setTime(int parameterIndex, Time x,
+     *       Calendar cal)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTime",
+        args = {int.class, java.sql.Time.class, java.util.Calendar.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return False on update.")
+    public void testSetTime_int_Time_Calendar() {
+
+        Calendar[] cals = { Calendar.getInstance(),
+                Calendar.getInstance(Locale.GERMANY),
+                Calendar.getInstance(TimeZone.getDefault()) };
+
+        Time[] times = { new Time(24, 25, 26), new Time(Integer.MAX_VALUE),
+                new Time(123456789) };
+
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (timeVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            for (int i = 0; i < times.length; i++) {
+                try {
+                    ps.setTime(1, times[i], cals[i]);
+                    assertFalse(ps.execute());
+                    assertTrue(ps.getUpdateCount() > 0);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                } finally {
+                    try {
+                        st.close();
+                    } catch (Exception ee) {
+                    }
+                }
+            }
+
+            try {
+                ps.setTime(2, times[0], cals[0]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            
+            ps.close();
+
+            try {
+                ps.setTime(-2, times[0], cals[1]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setTime(1, times[0], cals[2]);
+                ps1.execute();
+                
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.toString());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.PreparedStatement#setTimestamp(int parameterIndex,
+     *       Timestamp x)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTimestamp",
+        args = {int.class, java.sql.Timestamp.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testSetTimestamp_int_Timestamp() {
+
+        Timestamp[] timestamps = { new Timestamp(2007, 10, 17, 19, 06, 50, 23),
+                new Timestamp(123) };
+
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (TS) values (?);";
+            ps = conn.prepareStatement(query);
+          
+            for (int i = 0; i < timestamps.length; i++) {
+                try {
+                    ps.setTimestamp(1, timestamps[i]);
+                    assertFalse(ps.execute());
+                    assertTrue(ps.getUpdateCount() > 0);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+
+            try {
+                ps.setTimestamp(2, timestamps[0]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+
+            try {
+                ps.setTimestamp(-2, timestamps[0]);
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setTimestamp(1, timestamps[0]);
+                ps1.execute();
+                
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.toString());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setBlob(int, java.sql.Blob)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setBlob",
+        args = {int.class, java.sql.Blob.class}
+    )
+    public void testSetBlob() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        Blob mock = new MockBlob();
+        try {
+            String neverExecutedQuery = "select TBlob from type;";
+            ps = conn.prepareStatement(neverExecutedQuery);
+            ps.setBlob(1,mock);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            //ok 
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setClob(int, java.sql.Clob)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setClob",
+        args = {int.class, java.sql.Clob.class}
+    )
+    public void testSetClob() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        Clob mock = new MockClob();
+        try {
+            String neverExecutedQuery = "select TBlob from type;";
+            ps = conn.prepareStatement(neverExecutedQuery);
+            ps.setClob(1,mock);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setTimestamp(int, Timestamp, Calendar)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "setTimestamp",
+        args = {int.class, java.sql.Timestamp.class, java.util.Calendar.class}
+    )
+    @KnownFailure("preparedStatement.execute() does not return false on update.")
+    public void testSetTimestampIntTimestampCalendar() {
+        Calendar[] cals = { Calendar.getInstance(),
+                Calendar.getInstance(Locale.GERMANY),
+                Calendar.getInstance(TimeZone.getDefault()) };
+
+        Timestamp[] timestamps = { new Timestamp(2007, 10, 17, 19, 06, 50, 23),
+                new Timestamp(123) };
+
+        
+        PreparedStatement ps = null;
+        PreparedStatement ps1 = null;
+        try {
+            String query = "insert into type (timeVal) values (?);";
+            ps = conn.prepareStatement(query);
+            Statement st = null;
+            for (int i = 0; i < timestamps.length; i++) {
+                try {
+                    ps.setTimestamp(1, timestamps[i], cals[i]);
+                    assertFalse(ps.execute());
+                    assertTrue(ps.getUpdateCount() > 0);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown: " + sqle.getMessage());
+                } finally {
+                    try {
+                        st.close();
+                    } catch (Exception ee) {
+                    }
+                }
+            }
+
+            try {
+                ps.setTimestamp(2, timestamps[0], cals[0]);
+                ps.execute();
+                fail("SQLException is not thrown");
+            } catch (Exception sqle) {
+                // expected
+            }
+            ps.close();
+            try {
+                ps.setTimestamp(1, timestamps[0], cals[1]);
+                ps.execute();
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            String query1 = "insert into type (Tint) values (?);";
+            ps1 = conn.prepareStatement(query1);
+
+            try {
+                ps1.setTimestamp(1, timestamps[0], cals[2]);
+                ps1.execute();
+                
+            } catch (SQLException sqle) {
+                fail("SQLException is thrown: " + sqle.toString());
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                
+                ps.close();
+                ps1.close();
+            } catch (Exception ee) {
+            }
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setURL(int, java.net.URL)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setURL",
+        args = {int.class, java.net.URL.class}
+    )
+    public void testSetURL() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            ps.setURL(1, new URL("http://www.android.com"));
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+           //ok            
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setArray(int, java.sql.Array)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setArray",
+        args = {int.class, java.sql.Array.class}
+    )
+    public void testSetArray() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        Array a = new MockArray();
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            ps.setArray(1, new MockArray());
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            //ok      
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setRef(int, java.sql.Ref)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setRef",
+        args = {int.class, java.sql.Ref.class}
+    )
+    public void testSetRef() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        Ref mock = new MockRef();
+        try {
+            String neverExecutedQuery = "select TBlob from type;";
+            ps = conn.prepareStatement(neverExecutedQuery);
+            ps.setRef(1,mock);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setUnicodeStream(int, java.io.InputStream, int)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setUnicodeStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    public void testSetUnicodestream() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            InputStream file = Class.forName(this.getClass().getName())
+            .getResourceAsStream("/blob.c");
+            ps.setUnicodeStream(0, file, 100);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            //ok            
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setCharacterStream(int, java.io.Reader, int)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setCharacterStream",
+        args = {int.class, java.io.Reader.class, int.class}
+    )
+    public void testSetCharacterSteam() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            InputStream file = Class.forName(this.getClass().getName())
+            .getResourceAsStream("/blob.c");
+            assertNotNull("Error in test setup: file not found",file);
+            Reader reader = new InputStreamReader(file);
+            ps.setCharacterStream(1, reader, 100);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            // ok     
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setAsciiStream(int, InputStream, int)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setAsciiStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    public void testSetAxciiStream() {
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            InputStream file = Class.forName(this.getClass().getName())
+            .getResourceAsStream("/blob.c");
+            ps.setAsciiStream(0, file, 100);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            // ok       
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.PreparedStatement#setBinaryStream(int, InputStream, int)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setBinaryStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    public void testSetBinaryStream() {
+        
+        ResultSet res = null;
+        PreparedStatement ps = null;
+        try {
+            String query = "insert into type (TText) values (?);";
+            ps = conn.prepareStatement(query);
+            InputStream file = Class.forName(this.getClass().getName())
+            .getResourceAsStream("/blob.c");
+            ps.setBinaryStream(0, file, 100);
+            fail("Exception expected not supported"); 
+        } catch (SQLException e) {
+            // ok            
+        } catch (Exception e) {
+            fail("Error in test setup "+e.getMessage());
+            e.printStackTrace();
+        }
+    }
+    
+    private class MockRef implements Ref {
+
+        public String getBaseTypeName() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Object getObject() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Object getObject(Map<String, Class<?>> map) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public void setObject(Object value) throws SQLException {
+            // TODO Auto-generated method stub
+            
+        }
+        
+    }
+    
+    private class MockArray implements Array {
+
+        public Object getArray() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Object getArray(long index, int count) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Object getArray(long index, int count, Map<String, Class<?>> map)
+                throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Object getArray(Map<String, Class<?>> map) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public int getBaseType() throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public String getBaseTypeName() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public ResultSet getResultSet() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public ResultSet getResultSet(long index, int count)
+                throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public ResultSet getResultSet(long index, int count,
+                Map<String, Class<?>> map) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public ResultSet getResultSet(Map<String, Class<?>> map)
+                throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+        
+    }
+    
+    private class MockBlob implements Blob {
+
+        public InputStream getBinaryStream() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public byte[] getBytes(long pos, int length) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public long length() throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public long position(Blob pattern, long start) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public long position(byte[] pattern, long start) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public OutputStream setBinaryStream(long pos) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public int setBytes(long pos, byte[] theBytes) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public int setBytes(long pos, byte[] theBytes, int offset, int len)
+                throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public void truncate(long len) throws SQLException {
+            // TODO Auto-generated method stub
+            
+        }
+        
+    }
+    
+    private class MockClob implements Clob {
+
+        public InputStream getAsciiStream() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Reader getCharacterStream() throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public String getSubString(long pos, int length) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public long length() throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public long position(Clob searchstr, long start) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public long position(String searchstr, long start) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public OutputStream setAsciiStream(long pos) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public Writer setCharacterStream(long pos) throws SQLException {
+            // TODO Auto-generated method stub
+            return null;
+        }
+
+        public int setString(long pos, String str) throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public int setString(long pos, String str, int offset, int len)
+                throws SQLException {
+            // TODO Auto-generated method stub
+            return 0;
+        }
+
+        public void truncate(long len) throws SQLException {
+            // TODO Auto-generated method stub
+            
+        }
+        
+    }
+}
diff --git a/sql/src/test/java/tests/sql/RefTest.java b/sql/src/test/java/tests/sql/RefTest.java
new file mode 100644
index 0000000..6109623
--- /dev/null
+++ b/sql/src/test/java/tests/sql/RefTest.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Ref;
+import java.util.Map;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(Ref.class)
+public class RefTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Ref#getBaseTypeName()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getBaseTypeName",
+      args = {}
+      )
+    public void testGetBaseTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Ref#getObject()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {}
+      )
+    public void testGetObject() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Ref#getObject(java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getObject",
+      args = {Map.class}
+      )
+    public void testGetObjectMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Ref#setObject(java.lang.Object)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "setObject",
+          args = {Object.class}
+    )
+    public void testSetObject() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/ResultSetGetterTests.java b/sql/src/test/java/tests/sql/ResultSetGetterTests.java
new file mode 100644
index 0000000..302dbee
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ResultSetGetterTests.java
@@ -0,0 +1,2190 @@
+/*
+ * Copyright (C) 2007 Google Inc.
+ *
+ * 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.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.sql.DatabaseMetaData;
+import java.sql.Date;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Time;
+import java.sql.Timestamp;
+import java.util.Arrays;
+import java.util.Calendar;
+import java.util.GregorianCalendar;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.ListIterator;
+
+/**
+ * Tests based on  
+ * <a href="http://java.sun.com/products/jdbc/download.html">JDBC 1.0 API spec
+ * </a> Table 1.0
+ */
+@TestTargetClass(ResultSet.class)
+public class ResultSetGetterTests extends SQLTest {
+    
+    String queryAllSelect = "select * from type";
+    
+    ResultSet res = null;
+    
+    Statement st = null;
+    
+    // Judgement concerning support is based on the result of ResultSet.getOject
+    // and Table 1 of JDBC 1.0 spec.
+    static boolean booleanSupported = false;
+    static boolean blobSupported = false;
+    static boolean bigIntSupported = false;
+    static boolean smallIntSupported = false;
+    static boolean mediumIntSupported = false;
+    static boolean realSupported = false;
+    static boolean floatSupported = false;
+    static boolean dateSupported = false;
+    static boolean timeSupported = false;
+    static boolean timeStampSupported = false;
+    static boolean dateTimeSupported = false;
+    static boolean urlSupported= false;
+    static boolean tinyIntSupported = false;
+    static boolean decimalSupported = false;
+    static boolean numericSupported = false;
+    
+    static List<String> colNames = Arrays.asList("BoolVal", "IntVal", "LongVal",
+            "Bint", "Tint", "Sint", "Mint", "IntegerVal", "RealVal",
+            "DoubleVal", "FloatVal", "DecVal", "NumVal", "charStr",
+            "dateVal", "timeVal", "TS", "DT", "TBlob", "BlobVal", "MBlob",
+            "LBlob", "TText", "TextVal", "MText", "LText", "MaxLongVal",
+            "MinLongVal", "validURL", "invalidURL");
+    
+    static List<String> values = Arrays.asList("1", "-1", "22", "2", "33",
+         "3","1","2","3.9","23.2","33.3","44",
+        "5", "test string", "1799-05-26", "12:35:45", "2007-10-09 14:28:02.0",
+        "1221-09-22 10:11:55","1","2","3","4","Test text message tiny",
+        "Test text", "Test text message medium",
+        "Test text message long");
+    
+    static boolean[] supported = new boolean[]{
+        booleanSupported,
+        true,
+        true,
+        bigIntSupported,
+        tinyIntSupported,
+        smallIntSupported,
+        mediumIntSupported,
+        true,
+        realSupported,
+        true,
+        floatSupported,
+        decimalSupported,
+        numericSupported,
+        true,
+        dateSupported,
+        timeSupported,
+        timeStampSupported,
+        dateTimeSupported,
+        blobSupported,
+        blobSupported,
+        blobSupported,
+        blobSupported,
+        true,
+        true,
+        true,
+        true,
+        bigIntSupported,
+        bigIntSupported,
+        urlSupported,
+        urlSupported
+      };
+    
+    // Not supported: BIT,VARBINARY, LONGVARBINARY, BINARY, VARCHAR, LONGVARCHAR
+    static Class[] typeMap = new Class[]{
+            java.lang.String.class, //
+            java.lang.Integer.class,//Types.INTEGER,
+            java.lang.Integer.class, //Types.LONG, not a JDBC 1.0 type
+            java.lang.Long.class,  // Types.BIGINT,
+            java.lang.Byte.class,            // Types.TINYINT,
+            java.lang.Short.class, // Types.SMALLINT,
+            java.lang.Integer.class, //Types.MEDIUMINT, , not a JDBC 1.0 type
+            java.lang.Integer.class, // Types.Integer
+            java.lang.Float.class,   // Types.REAL,
+            java.lang.Double.class,  // Types.FLOAT,
+            java.lang.Double.class, // Types.DOUBLE,
+            java.math.BigDecimal.class, // Types.DECIMAL,
+            java.math.BigDecimal.class, // Types.NUMERIC,
+            java.lang.String.class,     // Types.CHAR
+            java.sql.Date.class,        // Types.DATE,
+            java.sql.Time.class,        // Types.TIME,
+            java.sql.Timestamp.class,  // Types.TIMESTAMP,
+            java.sql.Date.class,       // types datetime, not a JDBC 1.0 type
+            java.sql.Blob.class,       // Types.BLOB, not a JDBC 1.0 type
+            java.sql.Blob.class,       // Types.BLOB, not a JDBC 1.0 type
+            java.sql.Blob.class,       // Types.BLOB, not a JDBC 1.0 type
+            java.sql.Blob.class,       // Types.BLOB, not a JDBC 1.0 type
+            java.lang.String.class,    // not a JDBC 1.0 type
+            java.lang.String.class,    // not a JDBC 1.0 type
+            java.lang.String.class,    // not a JDBC 1.0 type
+            java.lang.String.class,    // not a JDBC 1.0 type
+            java.lang.Long.class,      // Types.BIGINT,
+            java.lang.Long.class,      // Types.BIGINT,
+            java.net.URL.class,        // not a JDBC 1.0 type
+            java.net.URL.class         // not a JDBC 1.0 type
+           
+            
+    };
+    
+    // first inserted row : actual values
+    // second inserted row: null values
+    String[] queries = {
+            "create table type (" +
+
+            " BoolVal BOOLEAN," + " IntVal INT," + " LongVal LONG,"
+                    + " Bint BIGINT," + " Tint TINYINT," + " Sint SMALLINT,"
+                    + " Mint MEDIUMINT, " +
+
+                    " IntegerVal INTEGER, " + " RealVal REAL, "
+                    + " DoubleVal DOUBLE, " + " FloatVal FLOAT, "
+                    + " DecVal DECIMAL, " +
+
+                    " NumVal NUMERIC, " + " charStr CHAR(20), "
+                    + " dateVal DATE, " + " timeVal TIME, " + " TS TIMESTAMP, "
+                    +
+
+                    " DT DATETIME, " + " TBlob TINYBLOB, " + " BlobVal BLOB, "
+                    + " MBlob MEDIUMBLOB, " + " LBlob LONGBLOB, " +
+
+                    " TText TINYTEXT, " + " TextVal TEXT, "
+                    + " MText MEDIUMTEXT, " + " LText LONGTEXT, " + 
+                    
+                    " MaxLongVal BIGINT, MinLongVal BIGINT, "+
+                    
+                    " validURL URL, invalidURL URL "+
+                    
+                    ");"
+             ,
+
+            "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,"
+                    + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal,"
+                    + "NumVal, charStr, dateVal, timeVal, TS,"
+                    + "DT, TBlob, BlobVal, MBlob, LBlob,"
+                    + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal,"
+                    + " validURL, invalidURL"
+                    + ") "
+                    + "values (1, -1, 22, 2, 33,"
+                    + "3, 1, 2, 3.9, 23.2, 33.3, 44,"
+                    + "5, 'test string', '1799-05-26', '12:35:45', '2007-10-09 14:28:02.0',"
+                    + "'1221-09-22 10:11:55', 1, 2, 3, 4,"
+                    + "'Test text message tiny', 'Test text',"
+                    + " 'Test text message medium', 'Test text message long', "
+                    + Long.MAX_VALUE+", "+Long.MIN_VALUE+", "
+                    + "'http://www.android.com', 'helloWorld' "+
+                    ");"
+            ,
+            
+           "insert into type (BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,"
+                    + "IntegerVal, RealVal, DoubleVal, FloatVal, DecVal,"
+                    + "NumVal, charStr, dateVal, timeVal, TS,"
+                    + "DT, TBlob, BlobVal, MBlob, LBlob,"
+                    + "TText, TextVal, MText, LText, MaxLongVal, MinLongVal,"
+                    +" validURL, invalidURL"
+                    + ") "
+                    + "values (null, null, null, null, null,"
+                    + "null, null, null, null, null, null, null,"
+                    + "null, null, null, null, null,"
+                    + "null, null, null, null, null,"
+                    + "null, null, null, null,null, null, null, null);" 
+    };
+    
+    @Override
+    public void setUp() {
+        super.setUp();
+        try {
+            conn.setAutoCommit(false);
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i]);
+            }
+            res = st.executeQuery(queryAllSelect);
+            assertTrue(res.next());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+    }
+    
+    public void tearDown() {     
+        try {
+            st.execute("drop table if exists type");
+            st.close();
+            res.close();
+        } catch (SQLException e) {
+            fail("SQLException is thrown "+e.getMessage());
+        } finally {
+            try {
+                st.close();
+                res.close();
+            } catch (SQLException ee) {
+            }
+        }
+        super.tearDown();
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Exception testing",
+        method = "getBytes",
+        args = {int.class}
+    )
+    public void testGetBytesInt() {
+        int i = 1;
+
+            
+        // null value
+        try {
+            i = 1;
+            res.next();
+            for (String t : values) {
+                assertNull(res.getBytes(i));
+                i++;
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.close();
+            res.getBytes(24);
+            fail("Should get Exception");
+        } catch (SQLException e) {
+            //ok
+        }
+
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(int)}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "VARBINARY value",
+        method = "getBytes",
+        args = {int.class}
+    )
+    @KnownFailure("last assertion fails: invalid conversion. Test passes on RI")
+    public void testGetBytesIntVarbinary() throws SQLException {
+
+        Statement st = null;
+        Statement stQuery = null;
+        PreparedStatement stPrep = null;
+        ResultSet res = null;
+
+        // setup
+        try {
+            String testString = "HelloWorld";
+            st = conn.createStatement();
+            st.executeUpdate("create table testBinary (VARBINARY value);");
+            stPrep = conn
+                    .prepareStatement("insert into testBinary values (?);");
+            stPrep.setBytes(1, testString.getBytes());
+            stPrep.execute();
+
+            stQuery = conn.createStatement();
+            res = stQuery.executeQuery("select * from testBinary");
+            try {
+                assertTrue(res.next());
+                byte[] output = res.getBytes(1);
+                String helloTest = new String(output);
+                assertNotNull(helloTest);
+                assertEquals(testString, helloTest);
+            } catch (SQLException e) {
+                fail("Unexpected exception: " + e.getMessage());
+            }
+        } finally {
+            if (res != null) res.close();
+            if (stPrep != null) stPrep.close();
+            if (st != null) st.close();
+            if (stQuery != null) stQuery.close();
+        }
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(int)}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "BINARY value",
+        method = "getBytes",
+        args = {int.class}
+    )
+     @KnownFailure("last assertion fails: invalid conversion. Test passes on RI")
+    public void testGetBytesIntBinary() throws SQLException {
+
+        Statement st = null;
+        Statement stQuery = null;
+        PreparedStatement stPrep = null;
+        ResultSet res = null;
+
+
+        // setup
+
+        String testString = "HelloWorld";
+        st = conn.createStatement();
+        st.executeUpdate("create table testBinary (BINARY value);");
+        stPrep = conn.prepareStatement("insert into testBinary values (?);");
+        stPrep.setBytes(1, testString.getBytes());
+        stPrep.execute();
+        try {
+            stQuery = conn.createStatement();
+            res = stQuery.executeQuery("select * from testBinary");
+            try {
+                assertTrue(res.next());
+                byte[] output = res.getBytes(1);
+                String helloTest = new String(output);
+                assertNotNull(helloTest);
+                assertEquals(testString, helloTest);
+            } catch (SQLException e) {
+                fail("Unexpected exception: " + e.getMessage());
+            }
+        } finally {
+            if (res != null) res.close();
+            if (stPrep != null) stPrep.close();
+            if (st != null) st.close();
+            if (stQuery != null) stQuery.close();
+        }
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Exception testing",
+        method = "getBytes",
+        args = {String.class}
+    )
+    public void testGetBytesString() {
+        int i = 1;
+        
+        // null value
+        try {
+
+            res.next();
+            for (String t : colNames) {
+                assertNull(res.getBytes(t));
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.close();
+            res.getBytes(colNames.get(24));
+            fail("Should get Exception");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(int)}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "VARBINARY value",
+        method = "getBytes",
+        args = {String.class}
+    )
+    @KnownFailure("last assertion fails: invalid conversion. Test passes on RI")
+    public void testGetBytesStringVarbinary() throws SQLException {
+
+        Statement st = null;
+        Statement stQuery = null;
+        PreparedStatement stPrep = null;
+        ResultSet res = null;
+
+        // setup
+        try {
+            String testString = "HelloWorld";
+            st = conn.createStatement();
+            st.executeUpdate("create table testBinary (VARBINARY value);");
+            stPrep = conn
+                    .prepareStatement("insert into testBinary values (?);");
+            stPrep.setBytes(1, testString.getBytes());
+            stPrep.execute();
+
+            stQuery = conn.createStatement();
+            res = stQuery.executeQuery("select value from testBinary");
+            try {
+                assertTrue(res.next());
+                byte[] output = res.getBytes("value");
+                String helloTest = new String(output);
+                assertNotNull(helloTest);
+                assertEquals(testString, helloTest);
+            } catch (SQLException e) {
+                fail("Unexpected exception: " + e.getMessage());
+            }
+        } finally {
+            if (res != null) res.close();
+            if (stPrep != null) stPrep.close();
+            if (st != null) st.close();
+            if (stQuery != null) stQuery.close();
+        }
+        
+    }
+        
+    /**
+     * Test method for {@link java.sql.ResultSet#getBytes(int)}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "BINARY value",
+        method = "getBytes",
+        args = {String.class}
+    )
+     @KnownFailure("last assertion fails: invalid conversion. Test passes on RI")
+    public void testGetBytesStringBinary() throws SQLException {
+    
+        Statement st = null;
+        Statement stQuery = null;
+        PreparedStatement stPrep = null;
+        ResultSet res = null;
+    
+    
+        // setup
+    
+        String testString = "HelloWorld";
+        st = conn.createStatement();
+        st.executeUpdate("create table testBinary (BINARY value);");
+        stPrep = conn.prepareStatement("insert into testBinary values (?);");
+        stPrep.setBytes(1, testString.getBytes());
+        stPrep.execute();
+        try {
+            stQuery = conn.createStatement();
+            res = stQuery.executeQuery("select value from testBinary");
+            try {
+                assertTrue(res.next());
+                byte[] output = res.getBytes("value");
+                String helloTest = new String(output);
+                assertNotNull(helloTest);
+                assertEquals(testString, helloTest);
+            } catch (SQLException e) {
+                fail("Unexpected exception: " + e.getMessage());
+            }
+        } finally {
+            if (res != null) res.close();
+            if (stPrep != null) stPrep.close();
+            if (st != null) st.close();
+            if (stQuery != null) stQuery.close();
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getConcurrency()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not fully supported: CONCUR_UPDATABLE not supported",
+        method = "getConcurrency",
+        args = {}
+    )
+    public void testGetConcurrency() {
+        try {
+            assertEquals(ResultSet.CONCUR_READ_ONLY, res.getConcurrency());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDate(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDate",
+        args = {int.class}
+    )
+    public void testGetDateInt() {
+        try {
+            
+            GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0);
+            Date input = new Date(testCal.getTimeInMillis());
+            Date d = res.getDate(15);
+            assertEquals(input.toString(),"1799-05-26");
+            assertEquals(input,d);
+           
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } 
+        try {
+            Date d = res.getDate(500);
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        } catch (Exception e) {
+            fail("Got unspecified Exception "+ e.getMessage());
+        }
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            Date d = res.getDate(15);
+            assertNull(d);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDate(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Not fully supported",
+        method = "getDate",
+        args = {int.class, java.util.Calendar.class}
+    )
+    public void testGetDateIntCalendar() {
+        GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0);
+        try {
+            
+            Date input = new Date(testCal.getTimeInMillis());
+            Date d = res.getDate(15, testCal);
+            
+            assertEquals(input.toString(),"1799-05-26");
+            assertEquals(input,d);
+           
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } 
+        try {
+            Date d = res.getDate(500, testCal);
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        } catch (Exception e) {
+            fail("Got unspecified Exception "+ e.getMessage());
+        }
+        
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            Date d = res.getDate(15,testCal);
+            assertNull(d);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDate(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Not fully supported",
+        method = "getDate",
+        args = {java.lang.String.class}
+    )
+    public void testGetDateString() {
+        try {
+            GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0);
+            Date input = new Date(testCal.getTimeInMillis());
+            Date d = res.getDate("dateVal");
+            assertEquals(input.toString(),"1799-05-26");
+            assertEquals(input,d);
+           
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } 
+        try {
+            Date d = res.getDate("bla");
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            Date d = res.getDate("dateVal");
+            assertNull(d);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDate(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDate",
+        args = {java.lang.String.class, java.util.Calendar.class}
+    )
+    public void testGetDateStringCalendar() {
+        GregorianCalendar testCal = new GregorianCalendar(1799, Calendar.MAY, 26, 0, 0);
+        try {
+            Date input = new Date(testCal.getTimeInMillis());
+            Date d = res.getDate("dateVal", testCal);
+            
+            assertEquals(input.toString(),"1799-05-26");
+            assertEquals(input,d);
+           
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } 
+        try {
+            Date d = res.getDate("bla", testCal);
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            Date d = res.getDate("dateVal",testCal);
+            assertNull(d);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDouble(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getDouble",
+        args = {int.class}
+    )
+    public void testGetDoubleInt() {
+        
+        double output = 0.0;
+        try {
+             double[] input = {2.0, 3.9 , 23.2};
+             
+             output = res.getDouble(8);
+             assertEquals(input[0],output);
+             
+             output = res.getDouble(9);
+             assertEquals(input[1],output);
+             
+             output = res.getDouble(10);
+             assertEquals(input[2],output);
+             
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try  {
+            res.getDouble(500);
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        // null value
+        try {
+            res.next();
+            output = res.getDouble(8);
+            assertEquals(0.0,output);
+            
+            output = res.getDouble(9);
+            assertEquals(0.0,output);
+            
+            output = res.getDouble(10);
+            assertEquals(0.0,output);
+            
+       } catch (SQLException e) {
+           fail("Unexpected exception: " + e.getMessage());
+       }
+       
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getDouble(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not fully supported: eg. getDouble from TinyInt ",
+        method = "getDouble",
+        args = {java.lang.String.class}
+    )
+    public void testGetDoubleString() {
+        double input = 23.2;
+        double output = 0.0;
+            
+        try{
+            output = res.getDouble("DoubleVal");
+            assertEquals (input,output);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try{
+            output = res.getDouble("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        // null value
+        try{
+            assertTrue(res.next());
+            output = res.getDouble("DoubleVal");
+            assertEquals (0.0 , output);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getFloat(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not fully supported: eg.: getFloat from TinyInt according to JDBC 1.0 spec",
+        method = "getFloat",
+        args = {int.class}
+    )
+    public void testGetFloatInt() {
+        float defaultF = 0.0f;
+        try {
+            float[] input = {3.9f, 23.2f, 33.3f};
+            
+            
+            float output = res.getFloat(9);
+            assertEquals(input[0], output);
+
+            output = res.getFloat(10);
+            assertEquals(input[1], output);
+
+            output = res.getFloat(11);
+            assertEquals(input[2], output);
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getFloat(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            float output = res.getFloat(8);
+            assertEquals(defaultF, output);
+
+            output = res.getFloat(9);
+            assertEquals(defaultF, output);
+
+            output = res.getFloat(10);
+            assertEquals(defaultF, output);
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getFloat(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not fully supported",
+        method = "getFloat",
+        args = {java.lang.String.class}
+    )
+    public void testGetFloatString() {
+        float defaultF = 0.0f;
+        try {
+            String[] input = {"RealVal", "DoubleVal", "FloatVal"};
+            float[] inputF = {3.9f, 23.2f, 33.3f};
+            
+            
+            float output = res.getFloat(input[0]);
+            assertEquals(inputF[0], output);
+
+            output = res.getFloat(input[1]);
+            assertEquals(inputF[1], output);
+
+            output = res.getFloat(input[2]);
+            assertEquals(inputF[2], output);
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getFloat(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            float output = res.getFloat(8);
+            assertEquals(defaultF, output);
+
+            output = res.getFloat(9);
+            assertEquals(defaultF, output);
+
+            output = res.getFloat(10);
+            assertEquals(defaultF, output);
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getInt(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getInt",
+        args = {int.class}
+    )
+    public void testGetIntInt() {
+
+        // real input val -1, 22, 2, 33,3, 1, 2
+        List<Integer> input = Arrays.asList(1, -1, 22, 2, 33,3, 1, 2);
+        ListIterator<Integer> it = input.listIterator();
+        Double test2 = new Double(23.2);
+        try {
+            for (int i = 1;i<9;i++ ) {
+                assertEquals(it.next().intValue(),res.getInt(i));
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getInt(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            for (int i = 2;i<11;i++ ) {
+                assertEquals(0,res.getInt(i));
+            }
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getInt(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getInt",
+        args = {java.lang.String.class}
+    )
+    public void testGetIntString() {
+        List<String> inputS = Arrays.asList("BoolVal", "IntVal", "LongVal",
+                "Bint", "Tint", "Sint", "Mint", "IntegerVal");
+        ListIterator<String> itS = inputS.listIterator();
+        List<Integer> input = Arrays.asList(1, -1, 22, 2, 33, 3, 1, 2);
+        ListIterator<Integer> it = input.listIterator();
+        try {
+            while (it.hasNext()) {
+                assertEquals(it.next().intValue(), res.getInt(itS.next()));
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getInt("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            for (String s : inputS) {
+                assertEquals(0, res.getInt(s));
+            }
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getLong(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getLong",
+        args = {int.class}
+    )
+    public void testGetLongInt() {
+        long maxVal = Long.MAX_VALUE;
+        long minVal = Long.MIN_VALUE;
+        
+        try {
+            assertEquals(maxVal, res.getLong(27));
+            assertEquals(minVal, res.getLong(28));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.getInt(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            
+            assertEquals(0,res.getLong(27));
+            assertEquals(0,res.getLong(28));
+            
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getLong(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getLong",
+        args = {java.lang.String.class}
+    )
+    public void testGetLongString() {
+        long maxVal = Long.MAX_VALUE;
+        long minVal = Long.MIN_VALUE;
+        
+        try {
+            assertEquals(maxVal, res.getLong("MaxLongVal"));
+            assertEquals(minVal, res.getLong("MinLongVal"));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.getInt("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+        try {
+            res.next();
+            
+            assertEquals(0,res.getLong("MaxLongVal"));
+            assertEquals(0,res.getLong("MinLongVal"));
+            
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getMetaData()}.
+     * type mappings according to 
+     * http://java.sun.com/j2se/1.3/docs/guide/jdbc/spec/jdbc-spec.frame8.html
+     * Not supported datatypes are not checked.
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "checks supported data types ,not supported types are not checked.",
+            method = "getMetaData",
+            args = {}
+        )
+    })
+    public void testGetMetaData() {
+        /*
+         * List<String> types = Arrays.asList("BOOLEAN", "INT", "LONG",
+         * "BIGINT", "TINYINT", "SMALLINT", "MEDIUMINT", "INTEGER", "REAL",
+         * "DOUBLE", "FLOAT", "DECIMAL", "NUMERIC", "CHAR(20)", "DATE", "TIME",
+         * "TIMESTAMP", "DATETIME", "TINYBLOB", "BLOB", "MEDIUMBLOB",
+         * "LONGBLOB", "TINYTEXT", "TEXT", "MEDIUMTEXT", "LONGTEXT", "BIGINT",
+         * "BIGINT","URL","URL");
+         */
+        List<String> types = Arrays.asList("VARCHAR", "INTEGER", "INTEGER",
+                "BIGINT", "SMALLINT", "SHORT", "INTEGER", "INTEGER", "FLOAT",
+                "DOUBLE", "DOUBLE", "DECIMAL", "NUMERIC", "VARCHAR", "DATE",
+                "TIME", "TIMESTAMP", "DATETIME", "BLOB", "BLOB", "BLOB",
+                "BLOB", "VARCHAR", "VARCHAR", "VARCHAR", "VARCHAR", "BIGINT",
+                "BIGINT", "URL", "URL");
+
+
+
+        ListIterator<String> it = types.listIterator();
+        ListIterator<String> colNameIt = colNames.listIterator();
+        try {
+            ResultSetMetaData meta = res.getMetaData();
+            assertNotNull(meta);
+            assertEquals("Error in test setup. Columns do not match", types
+                    .size(), meta.getColumnCount());
+            for (int i = 1; i < 31; i++) {
+                String colName = colNameIt.next();
+                String type = it.next();
+                if (supported[i - 1]) {
+                    assertTrue("Wrong column name at " + i, colName
+                            .equalsIgnoreCase(meta.getColumnName(i)));
+                    assertTrue("Wrong type at " + i, type.equalsIgnoreCase(meta
+                            .getColumnTypeName(i)));
+                }
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getObject(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported types BIT,VARBINARY, LONGVARBINARY, BINARY, VARCHAR, LONGVARCHAR",
+        method = "getObject",
+        args = {int.class}
+    )
+    public void testGetObjectInt() {
+
+        try {
+            for (int i = 1; i <= typeMap.length; i++) {
+                if (supported[i-1]) {
+                    Object value = res.getObject(i);
+                    assertTrue("value " + value.getClass().getName()
+                            + " does not correspond " + typeMap[i-1] + "at "+i, value
+                            .getClass().equals(typeMap[i-1]));
+                }
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.getObject(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        try {
+            res.next();
+            for (int i = 1; i <= typeMap.length; i++) {
+                    Object value = res.getObject(i);
+                   assertNull(value);
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+    }
+
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getObject(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not fully supported",
+        method = "getObject",
+        args = {java.lang.String.class}
+    )
+    public void testGetObjectString() {
+        ListIterator<String> colNameIt = colNames.listIterator();
+        try {
+            for (int i = 1; i <= typeMap.length; i++) {
+                String name = colNameIt.next();
+                if (supported[i-1]) {
+                    Object value = res.getObject(name);
+                    assertTrue("value " + value.getClass().getName()
+                            + " does not correspond " + typeMap[i-1] + "at "+i, value
+                            .getClass().equals(typeMap[i-1]));
+                }
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.getObject("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        
+        try {
+            colNameIt = colNames.listIterator();
+            res.next();
+            for (int i = 1; i <= typeMap.length; i++) {
+                    Object value = res.getObject(colNameIt.next());
+                   assertNull(value);
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+    }
+
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Exception testing missed, test fails. According to spec afterlast row is 0 but returns 3",
+        method = "getRow",
+        args = {}
+    )
+    @KnownFailure("If there is no current row 0 must be returned. res.close() does not wrap up")
+    public void testGetRow() {
+        try {
+            assertEquals(1, res.getRow());
+            assertTrue(res.isFirst());
+            res.next();
+            assertEquals(2, res.getRow());
+            assertTrue(res.isLast());
+            res.next();
+            assertTrue(res.isAfterLast());
+            assertEquals(0, res.getRow());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.close();
+            res.getRow();
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getShort(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getShort",
+        args = {int.class}
+    )
+    public void testGetShortInt() {
+        try {
+            short shorty = res.getShort(6);
+            assertEquals(3,shorty);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.next();
+            short shorty = res.getShort(6);
+            assertEquals(0,shorty);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            res.getShort(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getShort(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getShort",
+        args = {java.lang.String.class}
+    )
+    public void testGetShortString() {
+        try {
+            short shorty = res.getShort("Sint");
+            assertEquals(3,shorty);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.next();
+            short shorty = res.getShort("Sint");
+            assertEquals(0,shorty);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            res.getShort("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getStatement()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "test fails. According to spec info.getStatement should return"+
+        " null but an exception is thrown: stale result set.",
+        method = "getStatement",
+        args = {}
+    )
+    @KnownFailure("According to spec info.getStatement should return null"+
+            " but an exception is thrown: stale result set.")
+    public void testGetStatement() {
+        try {
+            DatabaseMetaData meta = conn.getMetaData();
+            ResultSet info = meta.getTypeInfo();
+            Statement statement2 = info.getStatement();
+            assertNull(statement2);
+        } catch(SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            Statement statement2 = res.getStatement();
+            assertEquals(st, statement2);
+        } catch(SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+       // exception testing
+        try {
+            res.close();
+            res.getStatement();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getString(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getString",
+        args = {int.class}
+    )
+    public void testGetStringInt() {
+        List<String> texts = Arrays.asList("Test text message tiny",
+                "Test text", "Test text message medium",
+                "Test text message long");
+        int i = 23;
+        
+        //text and exception testing
+        try {
+            for (String t : texts) {
+                assertEquals(t, res.getString(i));
+                i++;
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        // the rest: everything should work with getString
+        
+        texts = Arrays.asList("1", "-1", "22", "2", "33",
+         "3","1","2","3.9","23.2","33.3","44",
+        "5", "test string", "1799-05-26", "12:35:45", "2007-10-09 14:28:02.0",
+        "1221-09-22 10:11:55","1","2","3","4");
+        i= 1;
+        
+        try {
+            for (String t : texts) {
+                assertEquals(t, res.getString(i));
+                i++;
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        //null testing
+        
+        try {
+            i = 1;
+            res.next();
+            for (String t : values) {
+                assertNull(res.getString(i));
+                i++;
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        // exception testing
+        try {
+            res.getString(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getString(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "exception test missed",
+        method = "getString",
+        args = {java.lang.String.class}
+    )
+    public void testGetStringString() {
+       
+        ListIterator<String> colNameIt = colNames.listIterator();
+        try {
+            for (String t : values) {
+                assertEquals(t, res.getString(colNameIt.next()));
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.next();
+            
+            for  (String name: colNames) {
+                assertNull(res.getString(name));
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.getString("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTime(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTime",
+        args = {int.class}
+    )
+    @KnownFailure("getTime should return Time value for a TIMESTAMP type but returns null")
+    public void testGetTimeInt() {
+        // values "12:35:45", "2007-10-09 14:28:02.0", "1221-09-22 10:11:55"
+
+        Calendar cal = new GregorianCalendar();
+        cal.clear();
+        cal.set(Calendar.HOUR_OF_DAY, 12);
+        cal.set(Calendar.MINUTE, 35);
+        cal.set(Calendar.SECOND, 45);
+        cal.set(Calendar.MILLISECOND, 0);
+        // set with calendar value (correct init time: since epoch)
+        long millis = cal.getTime().getTime();
+        Time t1 = new java.sql.Time(millis);
+        assertNotNull("t1", t1);
+  
+        
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis2 = cal2.getTime().getTime();
+        Time t2 = new java.sql.Time(millis2); 
+
+        int i = 16;
+
+        try {
+            Time resTime = res.getTime(i);
+            assertNotNull("Pos " + i + " null", resTime);
+            assertEquals(t1.toString(), resTime.toString());
+            assertEquals(t1.getTime(), resTime.getTime());
+            assertEquals(t1, resTime);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        // Compatibility Test: TIMESTAMP value
+        i = 17;
+        
+        try {
+            Time resTime = res.getTime(i);
+            assertNotNull("Pos " + i + " null", resTime);
+            assertEquals(t2.toString(), resTime.toString());
+            assertEquals(t2.getTime(), resTime.getTime());
+            assertEquals(t2, resTime);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            i = 16;
+            res.next();
+            assertNull(res.getTime(i));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTime(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTime",
+        args = {int.class, java.util.Calendar.class}
+    )
+     @KnownFailure("getTime on TIMESTAMP value fails: returns null")
+    public void testGetTimeIntCalendar() {
+        List<Time> times = new LinkedList<Time>();
+        List<Calendar> cals = new LinkedList<Calendar>();
+        // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0",
+        // "1221-09-22 10:11:55");
+
+        Calendar cal1 = new GregorianCalendar();
+        cal1.clear();
+        cal1.set(Calendar.HOUR_OF_DAY, 12);
+        cal1.set(Calendar.MINUTE, 35);
+        cal1.set(Calendar.SECOND, 45);
+        cal1.set(Calendar.MILLISECOND, 0);
+
+        long millis = cal1.getTime().getTime();
+        Time t1 = new java.sql.Time(millis);
+        
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis2 = cal2.getTime().getTime();
+        Time t2 = new java.sql.Time(millis2); 
+
+        // TIME value
+
+        int i = 16;
+
+        try {
+                Time timeRes = res.getTime(i,new GregorianCalendar());
+                assertNotNull(timeRes);
+                assertEquals(t1.toString(), timeRes.toString());
+                assertEquals(t1.getTime(), timeRes.getTime());
+                assertEquals(t1, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        // TIMESTAMP value
+        i = 17;
+        
+        try {
+            Time timeRes = res.getTime(i,new GregorianCalendar());
+            assertNotNull(timeRes);
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2.getTime(), timeRes.getTime());
+            assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            res.next();
+            
+            for (Calendar c : cals) {
+                assertNull(res.getTime(16,c));
+                i++;
+            }
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500,Calendar.getInstance());
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTime(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "",
+        method = "getTime",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("getTime should return a Time value for a TIMESTAMP type but returns null")
+    public void testGetTimeString() {
+        List<Time> times = new LinkedList<Time>();
+        
+        List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+
+        // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0",
+        // "1221-09-22 10:11:55");
+
+        Calendar cal = new GregorianCalendar();
+        cal.clear();
+        cal.set(Calendar.HOUR_OF_DAY, 12);
+        cal.set(Calendar.MINUTE, 35);
+        cal.set(Calendar.SECOND, 45);
+        cal.set(Calendar.MILLISECOND, 0);
+        
+        long millis = cal.getTime().getTime();
+        Time t1 = new java.sql.Time(millis);
+        
+        String col = it.next();
+        
+        try {
+                Time timeRes = res.getTime(col);
+                assertNotNull(timeRes);
+                assertEquals(t1.toString(), timeRes.toString());
+                assertEquals(t1.getTime(), timeRes.getTime());
+                assertEquals(t1, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+        
+        long millis2 = cal.getTime().getTime();
+        Time t2 = new java.sql.Time(millis2);
+        
+        col = it.next();
+        
+        try {
+                Time timeRes = res.getTime(col);
+                assertNotNull(timeRes);
+                assertEquals(t2.toString(), timeRes.toString());
+                assertEquals(t2.getTime(), timeRes.getTime());
+                assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+
+        try {
+            res.next();
+           
+                assertNull(res.getTime(col));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTime(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Testing getTime with TIME, TIMESTAMP value",
+        method = "getTime",
+        args = {java.lang.String.class, java.util.Calendar.class}
+    )
+    @KnownFailure("getTime on TIMESTAMP value fails: returns null")
+    public void testGetTimeStringCalendar() {
+        List<Time> times = new LinkedList<Time>();
+
+        List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+        List<Calendar> cals = new LinkedList<Calendar>();
+
+        // Arrays.asList("12:35:45", "2007-10-09 14:28:02.0",
+        // "1221-09-22 10:11:55");
+
+        Calendar cal1 = new GregorianCalendar();
+        cal1.clear();
+        cal1.set(Calendar.HOUR_OF_DAY, 12);
+        cal1.set(Calendar.MINUTE, 35);
+        cal1.set(Calendar.SECOND, 45);
+        cal1.set(Calendar.MILLISECOND, 0);
+        
+        long millis = cal1.getTime().getTime();
+        Time t1 = new java.sql.Time(millis);
+        
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis2 = cal2.getTime().getTime();
+        Time t2 = new java.sql.Time(millis2); 
+
+        // TIME value
+        String col = it.next();
+
+        try {
+                Time timeRes = res.getTime(col, new GregorianCalendar());
+                assertNotNull(timeRes);
+                assertEquals(t1.toString(), timeRes.toString());
+                assertEquals(t1.getTime(), timeRes.getTime());
+                assertEquals(t1, res.getTime(col));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        //TIMESTAMP value
+        col = it.next();
+        
+        try {
+            Time timeRes = res.getTime(col, new GregorianCalendar());
+            assertNotNull(timeRes);
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2.getTime(), timeRes.getTime());
+            assertEquals(t2, res.getTime(col));
+    } catch (SQLException e) {
+        fail("Unexpected exception: " + e.getMessage());
+    }
+
+        
+
+        try {
+            res.next();
+                assertNull(res.getTime(stringTimes.get(0), new GregorianCalendar()));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTimestamp(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTimestamp",
+        args = {int.class}
+    )
+    public void testGetTimestampInt() {
+        List<Timestamp> times = new LinkedList<Timestamp>();
+
+        List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+        List<Calendar> cals = new LinkedList<Calendar>();
+
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis = cal2.getTime().getTime();
+        Timestamp t2 = new Timestamp(millis);
+        times.add(t2);
+        
+         Calendar cal3 = new GregorianCalendar();
+          cal3.set(Calendar.YEAR, 1221);
+          cal3.set(Calendar.MONTH, Calendar.SEPTEMBER);
+          cal3.set(Calendar.DATE, 22);
+         cal3.set(Calendar.HOUR_OF_DAY, 10);
+         cal3.set(Calendar.MINUTE, 11);
+         cal3.set(Calendar.SECOND, 55);
+         cal3.set(Calendar.MILLISECOND, 0);
+        
+         millis = cal3.getTime().getTime();
+         Timestamp t3 = new Timestamp(millis);
+         times.add(t3);
+         // TIMESTAMP value
+        int i = 17;
+     
+        try {
+            Timestamp timeRes = res.getTimestamp(i);
+            assertEquals(t2.toString(), timeRes.toString());
+             assertEquals(t2.getTime(), timeRes.getTime());
+             assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        // DATE value
+        i = 18;
+        try {
+            Timestamp timeRes = res.getTimestamp(i);
+            assertEquals(t3.toString(), timeRes.toString());
+             assertEquals(t3.getTime(), timeRes.getTime());
+             assertEquals(t3, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.next();
+            assertNull(res.getTime(i));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTimestamp(int, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTimestamp",
+        args = {int.class, java.util.Calendar.class}
+    )
+    public void testGetTimestampIntCalendar() {
+        List<Timestamp> times = new LinkedList<Timestamp>();
+
+        List<String> stringTimes = Arrays.asList("timeVal", "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+//        List<Calendar> cals = new LinkedList<Calendar>();
+
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis = cal2.getTime().getTime();
+        Timestamp t2 = new Timestamp(millis);
+        times.add(t2);
+        //
+         Calendar cal3 = new GregorianCalendar();
+          cal3.set(Calendar.YEAR, 1221);
+          cal3.set(Calendar.MONTH, Calendar.SEPTEMBER);
+          cal3.set(Calendar.DATE, 22);
+         cal3.set(Calendar.HOUR_OF_DAY, 10);
+         cal3.set(Calendar.MINUTE, 11);
+         cal3.set(Calendar.SECOND, 55);
+         cal3.set(Calendar.MILLISECOND, 0);
+        
+         millis = cal3.getTime().getTime();
+         Timestamp t3 = new Timestamp(millis);
+         times.add(t3);
+         
+//         cals.add(cal1);
+//         cals.add(cal2);
+//         cals.add(cal3);
+//
+//        ListIterator<Calendar> calIt = cals.listIterator();
+
+        int i = 17;
+
+        try {
+            Timestamp timeRes = res.getTimestamp(i,new GregorianCalendar());
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        i = 18;
+        
+        try {
+            Timestamp timeRes = res.getTimestamp(i,new GregorianCalendar());
+            assertEquals(t3.toString(), timeRes.toString());
+            assertEquals(t3, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.next();
+            assertNull(res.getTime(17,cal2));
+            assertNull(res.getTime(18,cal3));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTimestamp(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTimestamp",
+        args = {java.lang.String.class}
+    )
+    public void testGetTimestampString() {
+        List<Timestamp> times = new LinkedList<Timestamp>();
+
+        List<String> stringTimes = Arrays.asList( "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+//        List<Calendar> cals = new LinkedList<Calendar>();
+
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis = cal2.getTime().getTime();
+        Timestamp t2 = new Timestamp(millis);
+        times.add(t2);
+        //
+         Calendar cal3 = new GregorianCalendar();
+          cal3.set(Calendar.YEAR, 1221);
+          cal3.set(Calendar.MONTH, Calendar.SEPTEMBER);
+          cal3.set(Calendar.DATE, 22);
+         cal3.set(Calendar.HOUR_OF_DAY, 10);
+         cal3.set(Calendar.MINUTE, 11);
+         cal3.set(Calendar.SECOND, 55);
+         cal3.set(Calendar.MILLISECOND, 0);
+        
+         millis = cal3.getTime().getTime();
+         Timestamp t3 = new Timestamp(millis);
+         times.add(t3);
+         
+        String col = it.next();
+
+        try {
+            Timestamp timeRes = res.getTimestamp(col);
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2.getTime(), timeRes.getTime());
+            assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        // DATE value
+        col = it.next();
+        
+        try {
+            Timestamp timeRes = res.getTimestamp(col);
+            assertEquals(t3.toString(), timeRes.toString());
+            assertEquals(t3.toString(), timeRes.toString());
+            assertEquals(t3.getTime(), timeRes.getTime());
+            assertEquals(t3, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.next();
+            assertNull(res.getTime(stringTimes.get(0)));
+            assertNull(res.getTime(stringTimes.get(1)));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getTimestamp(java.lang.String, java.util.Calendar)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getTimestamp",
+        args = {java.lang.String.class, java.util.Calendar.class}
+    )
+    public void testGetTimestampStringCalendar() {
+        List<Timestamp> times = new LinkedList<Timestamp>();
+
+        List<String> stringTimes = Arrays.asList( "TS", "DT");
+        Iterator<String> it = stringTimes.iterator();
+
+        Calendar cal2 = new GregorianCalendar();
+        cal2.set(Calendar.YEAR, 2007);
+        cal2.set(Calendar.MONTH, Calendar.OCTOBER);
+        cal2.set(Calendar.DATE, 9);
+        cal2.set(Calendar.HOUR_OF_DAY, 14);
+        cal2.set(Calendar.MINUTE, 28);
+        cal2.set(Calendar.SECOND, 02);
+        cal2.set(Calendar.MILLISECOND, 0);
+
+        long millis = cal2.getTime().getTime();
+        Timestamp t2 = new Timestamp(millis);
+        times.add(t2);
+        //
+         Calendar cal3 = new GregorianCalendar();
+          cal3.set(Calendar.YEAR, 1221);
+          cal3.set(Calendar.MONTH, Calendar.SEPTEMBER);
+          cal3.set(Calendar.DATE, 22);
+         cal3.set(Calendar.HOUR_OF_DAY, 10);
+         cal3.set(Calendar.MINUTE, 11);
+         cal3.set(Calendar.SECOND, 55);
+         cal3.set(Calendar.MILLISECOND, 0);
+        
+         millis = cal3.getTime().getTime();
+         Timestamp t3 = new Timestamp(millis);
+         times.add(t3);
+
+        try {
+            Timestamp timeRes = res.getTimestamp(stringTimes.get(0),cal2);
+            assertEquals(t2.toString(), timeRes.toString());
+            assertEquals(t2.getTime(), timeRes.getTime());
+            assertEquals(t2, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+            // DATE value
+        try {
+            Timestamp timeRes = res.getTimestamp(stringTimes.get(1),cal3);
+            assertEquals(t3.toString(), timeRes.toString());
+            assertEquals(t3.getTime(), timeRes.getTime());
+            assertEquals(t3, timeRes);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        // calIt = cals.listIterator();
+
+        try {
+            res.next();
+            assertNull(res.getTime(stringTimes.get(0),cal2));
+            assertNull(res.getTime(stringTimes.get(1),cal3));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            res.getTime(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getType()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "SQLException checking missed. Only one ResultSet type supported: default values, Test fails.Not fully supported. Always returns ResultSet.TYPE_SCROLL_INSENSITIVE. Wrong default value.",
+        method = "getType",
+        args = {}
+    )
+    @KnownFailure("res.close() does not wrap up")
+    public void testGetType() {
+        try {
+            assertEquals(ResultSet.TYPE_FORWARD_ONLY, res.getType());
+        } catch (SQLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        }
+
+        try {
+            st.close();
+            res.getType();
+            fail("Exception not thrown.");
+        } catch (SQLException e) {
+            //ok
+        }
+
+    }
+    
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getURL(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not fully supported type",
+        method = "getURL",
+        args = {int.class}
+    )
+    public void testGetURLInt() {
+        try {
+            URL input = new URL("http://www.android.com");
+            URL validURL = res.getURL(29);
+            assertEquals(input, validURL);
+        } catch (SQLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        } catch (MalformedURLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        }
+        
+        try {
+            URL invalidURL = res.getURL(30);
+            assertNull(invalidURL);
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        try {
+            res.next();
+            assertNull(res.getURL(29));
+            assertNull(res.getURL(30));
+        } catch (SQLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        }
+        
+        try {
+            res.getURL(500);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getURL(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not fully supported type",
+        method = "getURL",
+        args = {java.lang.String.class}
+    )
+    public void testGetURLString() {
+        try {
+            URL input = new URL("http://www.android.com");
+            URL validURL = res.getURL("validURL");
+            assertEquals(input, validURL);
+        } catch (SQLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        } catch (MalformedURLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        }
+        
+        try {
+            URL invalidURL = res.getURL("invalidURL");
+            assertNull(invalidURL);
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        try {
+            res.next();
+            assertNull(res.getURL("validURL"));
+            assertNull(res.getURL("invalidURL"));
+        } catch (SQLException e) {
+            fail("Unexpected exception " + e.getMessage());
+        }
+        
+        try {
+            res.getURL("bla");
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+}
diff --git a/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java b/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java
new file mode 100755
index 0000000..deccd27
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java
@@ -0,0 +1,930 @@
+/*
+ * 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.sql.ResultSet;
+import java.sql.ResultSetMetaData;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Types;
+
+@TestTargetClass(ResultSetMetaData.class)
+public class ResultSetMetaDataTest extends SQLTest {
+
+    ResultSetMetaData rsmd = null;
+    Statement st = null;
+    ResultSet rs = null;
+
+    public void setUp() {
+        super.setUp();
+        try {
+            conn.setAutoCommit(false);
+            assertFalse(conn.getAutoCommit());
+            String query = "select * from zoo";
+            st = conn.createStatement();
+            st.execute(query);
+            rs = st.getResultSet();
+            rsmd = rs.getMetaData();
+        } catch (SQLException e) {
+            fail("Couldn't get ResultSetMetaData object");
+        }
+    }
+    
+    public void tearDown() {
+        try {
+            rs.close();
+            st.close();
+        } catch (SQLException e) {
+            fail("Couldn't close Statement object");
+        }
+        super.tearDown();
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getCatalogName(int column)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Catalog not supported.",
+        method = "getCatalogName",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testGetCatalogName() throws SQLException {
+        try {
+            assertNotNull(rsmd.getCatalogName(1));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            conn.close();
+            rsmd.getCatalogName(0);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnClassName(int column)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getColumnClassName",
+        args = {int.class}
+    )
+    public void testGetColumnClassName() {
+        try {
+            assertNotNull(rsmd);
+            assertEquals(Short.class.getName(), rsmd.getColumnClassName(1));
+            assertEquals(String.class.getName(), rsmd.getColumnClassName(2));
+            assertEquals(String.class.getName(), rsmd.getColumnClassName(3));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+
+        try {
+            String name  = rsmd.getColumnClassName(-1);
+            assertNull(name);
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        }
+        
+        try {
+            String name  = rsmd.getColumnClassName(4);
+            assertNull(name);
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        }
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnCount()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException checking test fails",
+        method = "getColumnCount",
+        args = {}
+    )
+    @KnownFailure("SQLException checking test fails")
+    public void testGetColumnCount() {
+        try {
+            assertEquals(3, rsmd.getColumnCount());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            rs.close();
+            rsmd.getColumnCount();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnLabel(int column)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getColumnLabel",
+        args = {int.class}
+    )
+    public void testGetColumnLabel() {
+        String[] labels = { "id", "name", "family" };
+        try {
+            for (int i = 0; i < rsmd.getColumnCount(); i++) {
+                String label = rsmd.getColumnLabel(i + 1);
+                assertTrue(labels[i].contains(label));
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            String label = rsmd.getColumnLabel(-1);
+            fail("SQLException expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        try {
+            String label = rsmd.getColumnLabel(5);
+            fail("SQLException expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnName(int column)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "getColumnName",
+        args = {int.class}
+    )
+    public void testGetColumnName() {
+        String[] labels = { "id", "name", "family" };
+        try {
+            for (int i = 0; i < rsmd.getColumnCount(); i++) {
+                String name = rsmd.getColumnName(i + 1);
+                assertEquals(labels[i], name);
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+
+        try {
+            String label = rsmd.getColumnName(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        try {
+            String label = rsmd.getColumnName(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnType(int column)
+     * 
+     * for extensive tests see: ResultSetGetterTest.testGetMetaData
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Not all types supported. More type checking done in ResultSetGetterTest.testGetMetaData",
+        method = "getColumnType",
+        args = {int.class}
+    )
+    public void testGetColumnType() {
+        int[] types = { Types.SMALLINT, Types.VARCHAR, Types.VARCHAR};
+        try {
+            for (int i = 0; i < rsmd.getColumnCount(); i++) {
+                int type = rsmd.getColumnType(i + 1);
+                assertEquals(types[i], type);
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+
+        try {
+            rsmd.getColumnType(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getColumnType(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @test java.sql.ResultSetMetaData#getColumnTypeName(int column)
+     * 
+     * for extensive tests see: ResultSetGetterTest.testGetMetaData
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not all types supported: see ResultSetGetterTests.",
+        method = "getColumnTypeName",
+        args = {int.class}
+    )
+    public void testGetColumnTypeName() {
+        try {
+            assertTrue("smallint".equalsIgnoreCase(rsmd.getColumnTypeName(1)));
+            assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(2)));
+            assertTrue("varchar".equalsIgnoreCase(rsmd.getColumnTypeName(3)));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+
+        try {
+            rsmd.getColumnTypeName(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getColumnTypeName(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @throws SQLException 
+     * @test java.sql.ResultSetMetaData#getTableName(int column)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "MAX/MIN/zero parameters checking missed",
+        method = "getTableName",
+        args = {int.class}
+    )
+    public void testGetTableName() throws SQLException {
+        try {
+            assertEquals("zoo", rsmd.getTableName(1));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        Statement st1 = null;
+        ResultSet rs1 = null;
+        try {
+            
+            String create = "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));";
+            String insert1 = "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');";
+            String insert2 = "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');";
+            String query = "select name, animal_id from hutch, zoo where zoo.id = 1" ;
+            st1 = conn.createStatement();
+            st1.executeUpdate(create);
+            st1.executeUpdate(insert1);
+            st1.executeUpdate(insert2);
+            
+            rs1 = st1.executeQuery(query);
+            assertNotNull(rs1);
+            ResultSetMetaData rsmd1 = rs1.getMetaData();
+            assertEquals("zoo", rsmd1.getTableName(1));
+            assertEquals("hutch", rsmd1.getTableName(2));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                if (rs1 != null) rs1.close();
+                if (st1 != null) {
+                    st1.executeUpdate("drop table if exists hutch");
+                    st1.close();
+                }
+            } catch (SQLException sqle) {
+            }
+        }
+
+        try {
+            String name = rsmd.getTableName(-1);
+            fail("SQLException Expected");
+        } catch (SQLException e) {
+            // ok
+        }
+        try {
+            String name = rsmd.getTableName(5);
+            fail("SQLException Expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#getPrecision(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fails: always returns 0, exception tests fail ,failing statements commented out",
+        method = "getPrecision",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testGetPrecision() throws SQLException {
+        Statement st2 = null;
+        Statement st3 = null;
+        ResultSetMetaData rsmd2 = null;
+        try {
+        int precisionNum = 10;
+        int scale = 3;
+        int precicisionReal = 10;
+        String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
+        "valueFloat FLOAT , scaleTest NUMERIC("+precisionNum+","+scale+"),"+
+        " valueReal REAL("+precicisionReal+")  );";
+        String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666, 100000);";
+        String select = "select * from DecimalNumbers;";
+        st2 = conn.createStatement();
+        st2.executeUpdate(createTable);
+        st2.executeUpdate(insert);
+        
+        st2.close();
+        
+        st3 = conn.createStatement();
+        rs = st3.executeQuery(select);
+        assertTrue(rs.next());
+        rsmd2 = rs.getMetaData();
+        
+        assertNotNull(rsmd2);
+        assertEquals(precicisionReal, rsmd2.getPrecision(4));
+        assertEquals(precisionNum,rsmd2.getPrecision(3));
+        assertTrue(rsmd2.getPrecision(2) > 0);
+        assertTrue(rsmd2.getPrecision(1) > 0);
+        
+        // non numeric field
+        try {
+            rsmd.getPrecision(3);
+        } catch (SQLException e1) {
+            System.out.println("ResultSetMetaDataTest.testGetPrecision()"+e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        
+        try {
+            rsmd.getPrecision(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getPrecision(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        
+        try {
+            rs.close();
+            rsmd.getPrecision(1);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        } finally  {
+            if (st2 != null) st2.close();
+            if (st3 != null) st3.close();
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#getScale(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns 0, exception tests fail"+
+        " no positive test case for black-box test possible: no default"+
+        " value indicated",
+        method = "getScale",
+        args = {int.class}
+    )
+    @KnownFailure("Not supported")
+    public void testGetScale() throws SQLException {
+        try {
+        int scale = 3;
+        String createTable = "create table DecimalNumbers ( valueDouble DOUBLE,"+
+        "valueFloat FLOAT , scaleTest NUMERIC(10,"+scale+")  );";
+        String insert = "insert into DecimalNumbers values (1.5, 20.55, 30.666);";
+        String select = "select * from DecimalNumbers;";
+        
+        Statement st = conn.createStatement();
+        st.executeUpdate(createTable);
+        st.executeUpdate(insert);
+        
+        rs = st.executeQuery(select);
+        ResultSetMetaData rsmd2 = rs.getMetaData();
+        
+        assertNotNull(rsmd2);
+        assertEquals(scale,rsmd2.getScale(3));
+        assertTrue(rsmd2.getScale(1) > 0);
+        assertTrue(rsmd2.getScale(2) > 0);
+        
+        try {
+            rsmd.getScale(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getScale(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        
+        
+        try {
+            conn.close();
+            rsmd.getScale(1);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        } finally  {
+            st.cancel();
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#getSchemaName(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Tests fail: always returns null. Feature only partially implemented. Missing: positive test.",
+        method = "getSchemaName",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testGetSchema() {
+        
+        try {
+            assertNull("Functionality is now supported. Change test",rsmd.getSchemaName(2));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        
+        
+        try {
+            rsmd.getSchemaName(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getSchemaName(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        
+        
+        try {
+            conn.close();
+            rsmd.getSchemaName(2);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isAutoIncrement(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Tests fail: always returns false, failing statements commented out. Feature only partially implemented.Missing: Test positive case",
+        method = "isAutoIncrement",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testisAutoIncrement() {
+        
+        try {
+            assertFalse(rsmd.isAutoIncrement(1));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        /*
+        // Exception testing
+        
+        try {
+            rsmd.isAutoIncrement(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isAutoIncrement(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        */
+        
+        try {
+            conn.close();
+            rsmd.getSchemaName(2);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isCaseSensitive(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns false. Exception tests fail, failing statements commented out. Feature only partially implemented.",
+        method = "isCaseSensitive",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsCaseSensitive() {
+        
+        try {
+            assertFalse(rsmd.isCaseSensitive(1));
+            assertFalse(rsmd.isCaseSensitive(2));
+            assertFalse(rsmd.isCaseSensitive(3));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        /*
+        // Exception testing
+        
+        try {
+            rsmd.isCaseSensitive(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isCaseSensitive(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        */
+        
+        try {
+            conn.close();
+            rsmd.isCaseSensitive(1);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isCurrency(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Tests fail: always returns false. Exceptions and tests non Numeric fields fail, failing statements commented out. Feature only partially implemented. May be an optional feature.",
+        method = "isCurrency",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsCurrency() {
+        
+        try {
+            assertFalse(rsmd.isCurrency(1));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.testGetScale()"+e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        
+        // Exception testing
+        
+        try {
+            rsmd.isCurrency(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isCurrency(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+ 
+        
+        try {
+            rs.close();
+            rsmd.isCurrency(1);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isDefinitelyWritable(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns true. Exceptions fail, Feature only partially implemented.",
+        method = "isDefinitelyWritable",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsDefinitlyWritable() {
+
+        try {
+            assertTrue(rsmd.isDefinitelyWritable(1));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.testisDefinitelyWritable()"
+                    + e1.getMessage());
+            e1.printStackTrace();
+        }
+
+        // Exception testing
+
+        try {
+            rsmd.isDefinitelyWritable(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isDefinitelyWritable(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isNullable(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns ResultSetMetaData.columnNullableUnknown. Exceptions fail, failing statements commented out. Feature only partially implemented. May be an optional feature.",
+        method = "isNullable",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsNullable() {
+
+        try {
+            assertEquals(ResultSetMetaData.columnNullable, rsmd
+                    .isNullable(1));
+            assertEquals(ResultSetMetaData.columnNullable, rsmd
+                    .isNullable(2));
+            assertEquals(ResultSetMetaData.columnNullable, rsmd
+                    .isNullable(3));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.isNullable()" + e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        /*
+        // Exception testing
+
+        try {
+            rsmd.isNullable(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isNullable(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        */
+
+    }
+   
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isReadOnly(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Tests fail: always returns false. Exceptions fail, Feature only partially implemented.",
+        method = "isReadOnly",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsReadOnly() {
+
+        try {
+            assertFalse(rsmd.isReadOnly(1));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
+            e1.printStackTrace();
+        }
+
+        // Exception testing
+
+        try {
+            rsmd.isReadOnly(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isReadOnly(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isSearchable(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns false. Exceptions fail, Feature only partially implemented. Missing: test for searchable field.",
+        method = "isSearchable",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsSearchable() {
+
+        try {
+            assertTrue(rsmd.isSearchable(1));
+            assertTrue(rsmd.isSearchable(2));
+            assertTrue(rsmd.isSearchable(3));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
+            e1.printStackTrace();
+        }
+
+        // Exception testing
+
+        try {
+            rsmd.isSearchable(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isSearchable(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isSigned(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail: always returns false. Exceptions and tests on non numeric fields fail, Feature only partially implemented. Missing: test positive result.",
+        method = "isSigned",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsSigned() {
+
+        try {
+            assertFalse(rsmd.isSigned(1));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.isSigned" + e1.getMessage());
+            e1.printStackTrace();
+        }
+
+        // Exception testing
+
+        try {
+            rsmd.isSigned(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isSigned(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#isWritable(int column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Not supported. Tests fail: always returns false. Exceptions and tests on non numeric fields fail, failing statements commented out. Feature only partially implemented.",
+        method = "isWritable",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testIsWritable() {
+
+        try {
+            assertTrue(rsmd.isWritable(1));
+            assertTrue(rsmd.isWritable(2));
+            assertTrue(rsmd.isWritable(3));
+        } catch (SQLException e1) {
+            fail("ResultSetMetaDataTest.isReadOnly" + e1.getMessage());
+            e1.printStackTrace();
+        }
+        
+        /*
+        // Exception testing
+
+        try {
+            rsmd.isWritable(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.isSigned(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        */
+    }
+    
+    
+    /**
+     * @test {@link java.sql.ResultSetMetaData#getColumnDisplaySize(int Column)}
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail. always returns 0. Missing case where display"+
+        " size greater than 0",
+        method = "getColumnDisplaySize",
+        args = {int.class}
+    )
+    @KnownFailure("not supported")
+    public void testGetColumnDisplaySize() {
+        try {
+            for (int i = 0; i < rsmd.getColumnCount(); i++) {
+                int size = rsmd.getColumnDisplaySize(i + 1);
+                assertTrue(size > 0);
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+
+        // Exception testing
+
+        try {
+            rsmd.getColumnDisplaySize(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+        try {
+            rsmd.getColumnDisplaySize(5);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }
+    }
+    
+}
diff --git a/sql/src/test/java/tests/sql/ResultSetNotSupportedTests.java b/sql/src/test/java/tests/sql/ResultSetNotSupportedTests.java
new file mode 100644
index 0000000..1009d94
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ResultSetNotSupportedTests.java
@@ -0,0 +1,1352 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import java.sql.Ref;
+import java.sql.ResultSet;
+
+@TestTargetClass(ResultSet.class)
+public class ResultSetNotSupportedTests extends SQLTest {
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getArray(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getArray",
+        args = {int.class}
+    )
+    public void testGetArrayInt() {
+        
+        fail();
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getArray(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getArray",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetArrayString() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getAsciiStream(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getAsciiStream",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetAsciiStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getAsciiStream(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getAsciiStream",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetAsciiStreamString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBigDecimal(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBigDecimal",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBigDecimalInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBigDecimal(int, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getBigDecimal",
+        args = {int.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBigDecimalIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBigDecimal(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBigDecimal",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBigDecimalString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBigDecimal(java.lang.String, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBigDecimal",
+        args = {java.lang.String.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBigDecimalStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBinaryStream(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBinaryStream",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBinaryStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBinaryStream(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBinaryStream",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBinaryStreamString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBlob(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBlob",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBlobInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getBlob(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBlob",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBlobString() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBoolean(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getBoolean",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBooleanInt() {
+        /*
+        try {
+            assertTrue(res.first());
+            boolean b = res.getBoolean(1);
+            assertTrue(b);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            boolean b = res.getBoolean(5);
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            boolean b = res.getBoolean(1);
+            assertFalse(b);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        */
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getBoolean(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getBoolean",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetBooleanString() {
+        fail("Not yet implemented");
+    }
+
+    
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getByte(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getByte",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetByteString() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getByte(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "getByte",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetByteInt() {
+        /*
+        try {
+            assertTrue(res.first());
+            byte b = res.getByte(14);
+            String testString = Byte.toString(b);
+            assertEquals("test string",testString);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            byte b = res.getByte(5);
+            fail("Should get exception");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        // null value 
+        try {
+            assertTrue(res.next());
+            byte b = res.getByte(14);
+            assertNull(b);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        */
+    }
+    
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getCharacterStream(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getCharacterStream",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetCharacterStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getCharacterStream(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getCharacterStream",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetCharacterStreamString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getClob(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getClob",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetClobInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getClob(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getClob",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetClobString() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getCursorName()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported, setColumnName is not supported, therefore GetColumname can not be tested",
+        method = "getCursorName",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetCursorName() {
+        /*
+        try {
+            assertNull(res.getCursorName());
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        ResultSet rs2 = null;
+        Statement stmt;
+        String inputCName = "my \"\"\"\"quoted\"\"\"\" cursor\"\"";
+        try {
+            assertNull(res.getCursorName());
+            stmt = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_READ_ONLY);
+            stmt.setCursorName(inputCName);
+            rs2 = stmt.executeQuery("select * from type");
+            rs2.next();
+            String name = rs2.getCursorName();
+            assertEquals(inputCName, name);
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            rs2.close();
+            rs2.getCursorName();
+            fail("Should throw exception");
+        } catch (Exception e) {
+            //ok
+        }
+        */
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getFetchDirection()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported.",
+        method = "getFetchDirection",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetFetchDirection() {
+        /*
+        try {
+            assertEquals(ResultSet.TYPE_FORWARD_ONLY, res.getFetchDirection());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        */
+    }
+    
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getFetchSize()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getFetchSize",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetFetchSize() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getObject(int, java.util.Map)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getObject",
+        args = {int.class, java.util.Map.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetObjectIntMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getObject(java.lang.String, java.util.Map)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getObject",
+        args = {java.lang.String.class, java.util.Map.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetObjectStringMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getRef(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getRef",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetRefInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getRef(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getRef",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetRefString() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getUnicodeStream(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getUnicodeStream",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetUnicodeStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#getUnicodeStream(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getUnicodeStream",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetUnicodeStreamString() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#getWarnings()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "getWarnings",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testGetWarnings() {
+        /*
+        try {
+        res.close();
+        res.getWarnings();
+        fail("Exception expected");
+        } catch (SQLException e) {
+           //ok
+        }
+        */
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#cancelRowUpdates()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "SQLException checking missed",
+        method = "cancelRowUpdates",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testCancelRowUpdates() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#deleteRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "deleteRow",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testDeleteRow() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#insertRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "insertRow",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testInsertRow() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#moveToCurrentRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "moveToCurrentRow",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testMoveToCurrentRow() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#moveToInsertRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "moveToInsertRow",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testMoveToInsertRow() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#refreshRow()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "refreshRow",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testRefreshRow() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#rowDeleted()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "rowDeleted",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testRowDeleted() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#rowInserted()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "rowInserted",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testRowInserted() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#rowUpdated()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "rowUpdated",
+        args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testRowUpdated() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#setFetchDirection(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setFetchDirection",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testSetFetchDirection() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#setFetchSize(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "setFetchSize",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testSetFetchSize() {
+        fail("Not yet implemented");
+    }
+    
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateArray(int, java.sql.Array)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateArray",
+        args = {int.class, java.sql.Array.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateArrayIntArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateArray(java.lang.String, java.sql.Array)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateArray",
+        args = {java.lang.String.class, java.sql.Array.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateArrayStringArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateAsciiStream(int, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateAsciiStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateAsciiStreamIntInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateAsciiStream(java.lang.String, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateAsciiStream",
+        args = {String.class, java.io.InputStream.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateAsciiStreamStringInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBigDecimal(int, java.math.BigDecimal)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBigDecimal",
+        args = {int.class, java.math.BigDecimal.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBigDecimalIntBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBigDecimal(java.lang.String, java.math.BigDecimal)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBigDecimal",
+        args = {java.lang.String.class, java.math.BigDecimal.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBigDecimalStringBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBinaryStream(int, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBinaryStream",
+        args = {int.class, java.io.InputStream.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBinaryStreamIntInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBinaryStream(java.lang.String, java.io.InputStream, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBinaryStream",
+        args = {java.lang.String.class, java.io.InputStream.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBinaryStreamStringInputStreamInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBlob(int, java.sql.Blob)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBlob",
+        args = {int.class, java.sql.Blob.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBlobIntBlob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBlob(java.lang.String, java.sql.Blob)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBlob",
+        args = {java.lang.String.class, java.sql.Blob.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBlobStringBlob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBoolean(int, boolean)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBoolean",
+        args = {int.class, boolean.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBooleanIntBoolean() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBoolean(java.lang.String, boolean)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBoolean",
+        args = {java.lang.String.class, boolean.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBooleanStringBoolean() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateByte(int, byte)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateByte",
+        args = {int.class, byte.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateByteIntByte() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateByte(java.lang.String, byte)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateByte",
+        args = {java.lang.String.class, byte.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateByteStringByte() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBytes(int, byte[])}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBytes",
+        args = {int.class, byte[].class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBytesIntByteArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateBytes(java.lang.String, byte[])}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateBytes",
+        args = {java.lang.String.class, byte[].class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateBytesStringByteArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateCharacterStream(int, java.io.Reader, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateCharacterStream",
+        args = {int.class, java.io.Reader.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateCharacterStreamIntReaderInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateCharacterStream(java.lang.String, java.io.Reader, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateCharacterStream",
+        args = {java.lang.String.class, java.io.Reader.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateCharacterStreamStringReaderInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateClob(int, java.sql.Clob)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateClob",
+        args = {int.class, java.sql.Clob.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateClobIntClob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateClob(java.lang.String, java.sql.Clob)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateClob",
+        args = {java.lang.String.class, java.sql.Clob.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateClobStringClob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateDate(int, java.sql.Date)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateDate",
+        args = {int.class, java.sql.Date.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateDateIntDate() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateDate(java.lang.String, java.sql.Date)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateDate",
+        args = {java.lang.String.class, java.sql.Date.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateDateStringDate() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateDouble(int, double)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateDouble",
+        args = {int.class, double.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateDoubleIntDouble() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateDouble(java.lang.String, double)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateDouble",
+        args = {java.lang.String.class, double.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateDoubleStringDouble() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateFloat(int, float)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateFloat",
+        args = {int.class, float.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateFloatIntFloat() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateFloat(java.lang.String, float)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateFloat",
+        args = {java.lang.String.class, float.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateFloatStringFloat() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateInt(int, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateInt",
+        args = {int.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateIntIntInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateInt(java.lang.String, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateInt",
+        args = {String.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateIntStringInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateLong(int, long)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateLong",
+        args = {int.class, long.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateLongIntLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateLong(java.lang.String, long)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateLong",
+        args = {java.lang.String.class, long.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateLongStringLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateNull(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateNull",
+        args = {int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateNullInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateNull(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateNull",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateNullString() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateObject(int, java.lang.Object)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateObject",
+        args = {int.class, java.lang.Object.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateObjectIntObject() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateObject(int, java.lang.Object, int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "",
+        method = "updateObject",
+        args = {int.class, java.lang.Object.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateObjectIntObjectInt() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateObject(String, Object) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateObject",
+            args = {String.class, Object.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateStringObject() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateObject(String, Object, int) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateObject",
+            args = {String.class, Object.class, int.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateStringObjectInt() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateRef(int, java.sql.Ref) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateRef",
+            args = {int.class, Ref.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateRefIntRef() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateRef(String, Ref) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateRef",
+            args = {String.class, Ref.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateRefStringRef() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateRow() }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateRow",
+            args = {}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateRow() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateShort(int, short) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateShort",
+            args = {int.class, short.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateShortIntShort() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateShort(String, short) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateShort",
+            args = {String.class, short.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateShortStringShort() {
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateString(int, String) }.
+     */
+    @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            notes = "",
+            method = "updateString",
+            args = {int.class, String.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateStringIntString() {
+        
+    }
+
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateTime(int, java.sql.Time)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateTime",
+        args = {int.class, java.sql.Time.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateTimeIntTime() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateTime(java.lang.String, java.sql.Time)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateTime",
+        args = {java.lang.String.class, java.sql.Time.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateTimeStringTime() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateTimestamp(int, java.sql.Timestamp)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateTimestamp",
+        args = {int.class, java.sql.Timestamp.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateTimestampIntTimestamp() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#updateTimestamp(java.lang.String, java.sql.Timestamp)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateTimestamp",
+        args = {java.lang.String.class, java.sql.Timestamp.class}
+    )
+    @KnownFailure("Not Supported")
+    public void testUpdateTimestampStringTimestamp() {
+        fail("Not yet implemented");
+    }
+   
+}
diff --git a/sql/src/test/java/tests/sql/ResultSetTest.java b/sql/src/test/java/tests/sql/ResultSetTest.java
new file mode 100644
index 0000000..600190a
--- /dev/null
+++ b/sql/src/test/java/tests/sql/ResultSetTest.java
@@ -0,0 +1,915 @@
+/*
+ * 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.TestTargets;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+import tests.support.DatabaseCreator;
+
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(ResultSet.class)
+public class ResultSetTest extends SQLTest {
+    
+    ResultSet target = null;
+    ResultSet emptyTarget = null;
+    ResultSet scrollableTarget = null;
+    ResultSet writableTarget = null;
+    Statement stForward = null;
+    Statement stScrollable = null;
+    Statement stWritable = null;
+    final String selectAllAnimals = "select id, name from zoo";
+    final String selectEmptyTable = "select * from "+DatabaseCreator.SIMPLE_TABLE1;
+    /* (non-Javadoc)
+     * @see junit.framework.TestCase#setUp()
+     */
+    @Override
+    public void setUp() {
+        super.setUp();
+        try {
+            conn.setAutoCommit(false);
+            stForward = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_READ_ONLY);
+            stForward.execute(selectAllAnimals);
+            target = stForward.getResultSet();
+            assertNotNull(target);
+            /*
+            // Scrollable ResultSet  (not supported) TODO => Ticket 91
+            stScrollable = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+                    ResultSet.CONCUR_READ_ONLY);
+            stScrollable.execute(selectAllAnimals);
+            scrollableTarget = stScrollable.getResultSet();
+            assertNotNull(scrollableTarget);
+            
+            //Writable ResultSet (not supported) TODO => Ticket 91
+            stWritable = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_UPDATABLE);
+            stWritable.execute(selectAllAnimals);
+            writableTarget = stWritable.getResultSet();
+            assertNotNull(writableTarget);
+            */
+            // empty table
+            stForward = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_READ_ONLY);
+            stForward.execute(DatabaseCreator.CREATE_TABLE_SIMPLE1);
+            stForward.execute(selectEmptyTable);
+            emptyTarget = stForward.getResultSet();
+            
+            
+        } catch (SQLException e) {
+            fail("SQLException was thrown: " + e.getMessage());
+        } 
+    }
+
+    /* (non-Javadoc)
+     * @see junit.framework.TestCase#tearDown()
+     */
+    public void tearDown() {
+        super.tearDown();
+        try {
+            target.close();
+            stForward.close();
+        } catch (SQLException e) {
+            fail("Error in test setup");
+            e.printStackTrace();
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#absolute(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "absolute",
+        args = {int.class}
+    )
+    public void testAbsolute() {
+        try {
+            assertTrue(target.isBeforeFirst());
+            assertFalse(target.absolute(0));
+            assertTrue(target.absolute(1));
+            assertTrue(target.isFirst());
+            assertTrue(target.absolute(-1));
+            assertTrue(target.isLast());
+            target.next();
+            assertTrue(target.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+//          Go back in position with forward only cursor
+            assertEquals(ResultSet.TYPE_FORWARD_ONLY, target.getFetchDirection());
+            target.absolute(2);
+            target.absolute(1);
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        }
+        
+        
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#afterLast()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "afterLast",
+        args = {}
+    )
+    @KnownFailure("res.close() does not wrap up")
+    public void testAfterLast() {
+        try {
+            target.afterLast();
+            assertTrue(target.isAfterLast());
+            assertFalse(target.next());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            emptyTarget.afterLast();
+            assertFalse(emptyTarget.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            target.beforeFirst();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            
+        }
+        
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#beforeFirst()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "beforeFirst",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testBeforeFirst() {
+        
+        try {
+            target.beforeFirst();
+            assertTrue(target.isBeforeFirst());
+            assertTrue(target.next());
+            assertFalse(target.isBeforeFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            emptyTarget.beforeFirst();
+            assertFalse(emptyTarget.isBeforeFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            target.beforeFirst();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            
+        }
+        
+       
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#clearWarnings()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "Not supported",
+        method = "clearWarnings",
+        args = {}
+    )
+    @KnownFailure("Not supported")
+    public void testClearWarnings() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#close()}. 
+     * 
+     * According to the JDBC spec close has to "Releases this ResultSet
+     * object's database and JDBC resources immediately", and this implies
+     * the fields should be released as well (so that garbage collection 
+     *  can take place)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "test immediate release of resources, test fails",
+        method = "close",
+        args = {}
+    )
+    @KnownFailure("Resultset.close() does not wrap up")
+    public void testClose1() {
+        try {
+            target.close();
+            target.next();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#close()}. 
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "test that exception in one prepared statement does not affect second statement. (Atomicity Rule)",
+        method = "close",
+        args = {}
+    )
+    public void testClose() {
+        PreparedStatement ps1 = null;
+        PreparedStatement ps2 = null;
+        try {
+            
+            Statement s = conn.createStatement();
+            s.addBatch("create table t1 (a text);");
+
+            s.addBatch("insert into t1 values('abc');");
+            s.addBatch("insert into t1 values('def');");
+            s.addBatch("insert into t1 values('ghi');");
+            s.executeBatch();
+            s.close();
+
+            conn.commit();
+            ps1 = conn.prepareStatement("select * from t1");
+            ps2 = conn
+                    .prepareStatement("select * from t1 whe a like '?000'");
+
+            ResultSet rs1 = ps1.executeQuery();
+
+            try {
+                ResultSet rs2 = ps2.executeQuery();
+                while (rs2.next()){
+                    // do nothing
+                }
+                fail("Should get SQLException");
+            } catch (SQLException sqle) {
+                // ok : Division by zero
+            }
+
+            // Although exception happened on ps2 rs1 should still work 
+            // Isolation property if ACID rules
+            
+            while (rs1.next()) {
+                // do nothing: switching of rows should be possible
+            }
+
+            conn.commit();
+
+            rs1.close();
+            ps1.close();
+            ps2.close();
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } finally {
+            try {
+                if (ps1 != null) ps1.close();
+                if (ps2 != null) ps2.close();
+                conn.rollback();
+            } catch (SQLException e) {
+                // TODO Auto-generated catch block
+                e.printStackTrace();
+            }
+        }
+    }
+    
+    
+
+    /**
+     * Test method for {@link java.sql.ResultSet#findColumn(java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "findColumn",
+        args = {java.lang.String.class}
+    )
+    public void testFindColumn() {
+        try {
+            assertEquals(1, target.findColumn("id"));
+            assertEquals(2, target.findColumn("name"));
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+           
+        try {
+            target.findColumn("bla");
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#first()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "first",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testtestFirst() {
+        try {
+            assertFalse(emptyTarget.first());
+            assertTrue(target.first());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            // releases all resources such that it can be finalized!
+            target.first();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            
+        }
+        
+        
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#isAfterLast()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "isAfterLast",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testtestIsAfterLast() {
+        try {
+            assertFalse(target.isAfterLast());
+            target.absolute(-1); // last
+            target.next();
+            assertTrue(target.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            assertFalse(emptyTarget.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            // releases all resources such that it can be finalized!
+            target.isAfterLast();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#isBeforeFirst()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "isBeforeFirst",
+        args = {}
+    )
+    @KnownFailure("In Second code block assertion fails. statment. "+
+            "close() does not wrap up")
+    public void testtestIsBeforeFirst() {
+        try {
+            assertTrue(target.isBeforeFirst());
+            assertTrue(target.next());
+            assertFalse(target.isBeforeFirst());
+            assertTrue(target.isFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            assertTrue(emptyTarget.isBeforeFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            // releases all resources such that it can be finalized!
+            target.isBeforeFirst();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#isFirst()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "isFirst",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testtestIsFirst() {
+        try {
+            assertFalse(target.isFirst());
+            target.first();
+            assertTrue(target.isFirst());
+            target.next();
+            assertFalse(target.isFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            assertFalse(emptyTarget.isFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            // releases all resources such that it can be finalized!
+            target.isFirst();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            
+        }
+       
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#isLast()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails. Test for empty result set fails",
+        method = "isLast",
+        args = {}
+    )
+    @KnownFailure("Second block first assertion fails. Is Last should evaluate "+
+            "true if the row on which the cursor is actually provides a result."+
+            "statment.close() does not wrap up")
+    public void testtestIsLast() {
+        
+        try {
+            assertFalse(target.isLast());
+            target.absolute(-1);
+            assertTrue(target.isLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        //check default value no valid row
+        try {
+            assertFalse(emptyTarget.isLast());
+            assertFalse(emptyTarget.next());
+            assertFalse(emptyTarget.isLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        
+        try {
+            target.close();
+            target.isLast();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        }
+       
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#last()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "last",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testtestLast() {
+        try {
+            assertFalse(target.isLast());
+            target.last();
+            assertTrue(target.isLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        
+        try {
+            target.close();
+            target.last();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        }
+      
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#next()}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "SQLException checking test fails. Clearing of warnings"+
+                " and closed streams not supported.",
+        method = "next",
+        args = {}
+    )
+    @KnownFailure("Resultset.close() does not wrap up")
+    public void testNext() throws SQLException {
+        try {
+            //before first - first
+            assertTrue(target.next());
+            //first - second
+            assertTrue(target.next());
+            //after last
+            assertFalse(target.next());
+            assertTrue(target.isAfterLast());
+            // one more
+            assertFalse(target.next());
+            
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            assertFalse(emptyTarget.next());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        target.close();
+        try {
+            target.next();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#previous()}.
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "tests SQLException",
+        method = "previous",
+        args = {}
+    )
+    public void testPrevious() {
+        
+        try {
+            assertEquals(ResultSet.FETCH_FORWARD, target.getFetchDirection());
+            target.last();
+            target.previous();
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        }
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#previous()}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "not supported",
+        method = "previous",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void testPrevious2() throws SQLException {
+        /*
+        try {
+            assertSame(ResultSet.TYPE_SCROLL_INSENSITIVE, scrollableTarget.getFetchDirection());
+            
+            target.first();
+            target.previous();
+            assertTrue(target.isBeforeFirst());
+            
+            target.last();
+            target.next();
+            target.previous();
+            assertFalse(target.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        target.close();
+        try {
+            target.previous();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        */
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#relative(int)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "test fails: no exception is thrown when moving cursor backwards",
+        method = "relative",
+        args = {int.class}
+    )
+    @KnownFailure("no exception is thrown when moving cursor backwards"
+            +" on forward only statement")
+    public void testRelative() {
+
+        // forward only
+        try {
+            int initialRow = target.getRow();
+            assertFalse(target.relative(0));
+            assertEquals(initialRow, target.getRow());
+            
+            assertTrue(target.relative(1));
+            assertTrue(target.isFirst());
+            assertEquals(1, target.getRow());
+
+            assertTrue(target.relative(1));
+            assertFalse(target.isFirst());
+            assertEquals(2, target.getRow());
+            
+            
+            assertFalse(target.relative(2));
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+
+        try {
+            // should not be able to scroll backwards in forward only RS 
+            target.relative(-2);
+            assertEquals(2,target.getRow());
+            fail("Should get SQLException");
+        } catch (SQLException e) {
+            // ok
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            assertFalse(emptyTarget.relative(Integer.MAX_VALUE));
+            assertTrue(emptyTarget.isAfterLast());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+    }
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#relative(int)}.
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "test fails: does not move before first row on min_value",
+        method = "relative",
+        args = {int.class}
+    )
+    @KnownFailure("Scrollable resultSet. Not supported")
+    public void testRelativeScrollableResultSet() throws SQLException {
+     // scrollable resultSet 
+        /*
+        try {
+            
+            int initialRow = scrollableTarget.getRow();
+            assertFalse(scrollableTarget.relative(0));
+            assertEquals(initialRow, scrollableTarget.getRow());
+            
+            assertTrue(scrollableTarget.relative(1));
+            assertTrue(scrollableTarget.isFirst());
+            assertEquals(1, scrollableTarget.getRow());
+
+            assertTrue(scrollableTarget.relative(1));
+            assertFalse(scrollableTarget.isFirst());
+
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+
+        try {
+            assertEquals(2, scrollableTarget.getRow());
+            assertFalse(scrollableTarget.relative(2));
+            scrollableTarget.relative(-2);
+            assertEquals(2,scrollableTarget.getRow());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+            assertFalse(scrollableTarget.relative(Integer.MIN_VALUE));
+            assertTrue(scrollableTarget.isBeforeFirst());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } catch (Exception e) {
+            fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        stScrollable.close();
+        try {
+            scrollableTarget.relative(1);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        */
+    }
+    
+
+   
+    /**
+     * Test method for {@link java.sql.ResultSet#updateObject(java.lang.String, java.lang.Object)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "not supported",
+        method = "updateObject",
+        args = {java.lang.String.class, java.lang.Object.class}
+    )
+    @KnownFailure("not supported")
+    public void testUpdateObjectStringObject() {
+        /*
+        try {
+           writableTarget.next();
+           writableTarget.updateObject("family","bird");
+        } catch (SQLException e) {
+           fail("Unexpected exception: " + e.getMessage());
+        }
+        
+        try {
+           target.next();
+           target.updateObject("family","bird");
+           fail("SQLException was not thrown");
+        } catch (SQLException e) {
+           fail("Unexpected exception: " + e.getMessage());
+        }
+        */
+    }
+
+    
+    /**
+     * Test method for {@link java.sql.ResultSet#updateString(java.lang.String, java.lang.String)}.
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported. Only exception testing. Missing testing for wrong type",
+        method = "updateString",
+        args = {java.lang.String.class, java.lang.String.class}
+    )
+    @KnownFailure("Feature not supported")
+    public void testUpdateStringStringString() throws Exception {
+        /*
+        try {
+            writableTarget.next();
+            writableTarget.updateString("family","bird");
+         } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+         }
+         
+         // non writable target.
+         try {
+            target.next();
+            target.updateString("family","bird");
+            fail("SQLException was not thrown");
+         } catch (SQLException e) {
+            //ok
+         }
+         
+         
+         // writable but wrong type
+         try {
+             target.updateString(1,"test");
+         } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+         }
+         
+         target.close();
+         
+      // Exception test
+         try {
+             target.updateString("family","test");
+             fail("Exception expected");
+         } catch (SQLException e) {
+            //ok
+         }
+         */
+    }
+
+    /**
+     * Test method for {@link java.sql.ResultSet#wasNull()}.
+     * Spec sais: if something was read... -> if nothing was read it should be false
+     * @throws SQLException 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "failing tests.",
+        method = "wasNull",
+        args = {}
+    )
+    @KnownFailure("the default tests, and exception tests fail.")
+    public void testWasNull() throws SQLException {
+        
+        // Check default: select statement executed but no get on target called yet
+        // Either false or throw an exception.
+        try {
+            assertFalse(target.wasNull());
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        
+        try {
+            stForward.execute("insert into zoo values(8,null,null);");
+            stForward.execute(selectAllAnimals);
+            target = stForward.getResultSet();
+            assertNotNull(target);
+            assertTrue(target.last());
+            assertNull(target.getObject(2));
+            assertTrue(target.wasNull());
+            assertNotNull(target.getObject(1));
+            assertFalse(target.wasNull());
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+            e.printStackTrace();
+        }
+        
+        target.close();
+        try {
+            target.wasNull();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+}
diff --git a/sql/src/test/java/tests/sql/SQLDataTest.java b/sql/src/test/java/tests/sql/SQLDataTest.java
new file mode 100644
index 0000000..1aed820
--- /dev/null
+++ b/sql/src/test/java/tests/sql/SQLDataTest.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.SQLData;
+import java.sql.SQLInput;
+import java.sql.SQLOutput;
+
+
+@TestTargetClass(SQLData.class)
+public class SQLDataTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.SQLData#getSQLTypeName()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getSQLTypeName",
+          args = {}
+        )
+    public void testGetSQLTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLData#readSQL(java.sql.SQLInput, java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readSQL",
+          args = {SQLInput.class, String.class}
+        )
+    public void testReadSQL() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLData#writeSQL(java.sql.SQLOutput)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "writeSQL",
+          args = {SQLOutput.class}
+        )
+    public void testWriteSQL() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/SQLInputTest.java b/sql/src/test/java/tests/sql/SQLInputTest.java
new file mode 100644
index 0000000..3ed37de
--- /dev/null
+++ b/sql/src/test/java/tests/sql/SQLInputTest.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.SQLInput;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(SQLInput.class)
+public class SQLInputTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readString()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readString",
+          args = {}
+    )
+    public void testReadString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readBoolean()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readBoolean",
+          args = {}
+        )
+    public void testReadBoolean() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readByte()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readByte",
+          args = {}
+        )public void testReadByte() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readShort()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readShort",
+          args = {}
+        )
+    public void testReadShort() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readInt()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readInt",
+          args = {}
+        )
+    public void testReadInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readLong()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readLong",
+          args = {}
+        )
+    public void testReadLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readFloat()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readFloat",
+          args = {}
+        )
+    public void testReadFloat() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readDouble()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readDouble",
+          args = {}
+        )
+    public void testReadDouble() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readBigDecimal()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readBigDecimal",
+          args = {}
+        )
+    public void testReadBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readBytes()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readBytes",
+          args = {}
+        )
+    public void testReadBytes() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readDate()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readDate",
+          args = {}
+        )
+    public void testReadDate() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readTime()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readTime",
+          args = {}
+        )
+    public void testReadTime() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readTimestamp()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readTimestamp",
+          args = {}
+        )
+    public void testReadTimestamp() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readCharacterStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readCharacterStream",
+          args = {}
+        )
+    public void testReadCharacterStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readAsciiStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readAsciiStream",
+          args = {}
+        )
+    public void testReadAsciiStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readBinaryStream()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readBinaryStream",
+          args = {}
+        )
+    public void testReadBinaryStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readObject()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readObject",
+          args = {}
+        )
+    public void testReadObject() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readRef()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readRef",
+          args = {}
+        )
+    public void testReadRef() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readBlob()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readBlob",
+          args = {}
+    )
+    public void testReadBlob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readClob()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readClob",
+          args = {}
+        )
+    public void testReadClob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readArray()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readArray",
+          args = {}
+        )
+    public void testReadArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#wasNull()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "wasNull",
+          args = {}
+        )
+    public void testWasNull() {
+    fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLInput#readURL()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "readURL",
+          args = {}
+    )
+    public void testReadURL() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/SQLOutputTest.java b/sql/src/test/java/tests/sql/SQLOutputTest.java
new file mode 100644
index 0000000..13ef4b1
--- /dev/null
+++ b/sql/src/test/java/tests/sql/SQLOutputTest.java
@@ -0,0 +1,347 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.io.InputStream;
+import java.io.Reader;
+import java.math.BigDecimal;
+import java.net.URL;
+import java.sql.Array;
+import java.sql.Blob;
+import java.sql.Clob;
+import java.sql.Date;
+import java.sql.Ref;
+import java.sql.SQLData;
+import java.sql.SQLOutput;
+import java.sql.Struct;
+import java.sql.Time;
+import java.sql.Timestamp;
+
+@TestTargetClass(SQLOutput.class)
+public class SQLOutputTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeString(java.lang.String)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeString",
+      args = {String.class}
+      )
+    public void testWriteString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeBoolean(boolean)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeBoolean",
+      args = {boolean.class}
+      )
+    public void testWriteBoolean() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeByte(byte)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeByte",
+      args = {byte.class}
+      )
+    public void testWriteByte() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeShort(short)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeShort",
+      args = {short.class}
+      )
+    public void testWriteShort() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeInt(int)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeInt",
+      args = {int.class}
+      )
+    public void testWriteInt() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeLong(long)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeLong",
+      args = {long.class}
+      )
+    public void testWriteLong() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeFloat(float)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeFloat",
+      args = {float.class}
+      )
+    public void testWriteFloat() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeDouble(double)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeDouble",
+      args = {double.class}
+      )
+    public void testWriteDouble() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for
+     * {@link java.sql.SQLOutput#writeBigDecimal(java.math.BigDecimal)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeBigDecimal",
+      args = {BigDecimal.class}
+      )
+    public void testWriteBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeBytes(byte[])}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeBytes",
+      args = {byte[].class}
+    )
+    public void testWriteBytes() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeDate(java.sql.Date)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeDate",
+      args = {Date.class}
+      )
+    public void testWriteDate() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeTime(java.sql.Time)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeTime",
+      args = {Time.class}
+      )
+    public void testWriteTime() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for
+     * {@link java.sql.SQLOutput#writeTimestamp(java.sql.Timestamp)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeTimestamp",
+      args = {Timestamp.class}
+      )
+    public void testWriteTimestamp() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for
+     * {@link java.sql.SQLOutput#writeCharacterStream(java.io.Reader)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeCharacterStream",
+      args = {Reader.class}
+      )
+    public void testWriteCharacterStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for
+     * {@link java.sql.SQLOutput#writeAsciiStream(java.io.InputStream)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeAsciiStream",
+      args = {InputStream.class}
+      )
+    public void testWriteAsciiStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for
+     * {@link java.sql.SQLOutput#writeBinaryStream(java.io.InputStream)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeBinaryStream",
+      args = {InputStream.class}
+      )
+    public void testWriteBinaryStream() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeObject(java.sql.SQLData)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeObject",
+      args = {SQLData.class}
+      )
+    public void testWriteObject() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeRef(java.sql.Ref)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeRef",
+      args = {Ref.class}
+      )
+    public void testWriteRef() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeBlob(java.sql.Blob)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeBlob",
+      args = {Blob.class}
+      )
+    public void testWriteBlob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeClob(java.sql.Clob)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeClob",
+      args = {Clob.class}
+      )
+    public void testWriteClob() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeStruct(java.sql.Struct)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeStruct",
+      args = {Struct.class}
+      )
+    public void testWriteStruct() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeArray(java.sql.Array)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeArray",
+      args = {Array.class}
+      )
+    public void testWriteArray() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.SQLOutput#writeURL(java.net.URL)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "writeURL",
+      args = {URL.class}
+      )
+    public void testWriteURL() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/SQLTest.java b/sql/src/test/java/tests/sql/SQLTest.java
new file mode 100755
index 0000000..9d9051d
--- /dev/null
+++ b/sql/src/test/java/tests/sql/SQLTest.java
@@ -0,0 +1,138 @@
+/*
+ * 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.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import java.io.File;
+import java.io.IOException;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+
+@TestTargetClass(Statement.class)
+public class SQLTest extends TestCase {
+    static Connection conn;
+
+    public void setUp() {
+        getSQLiteConnection();
+        createZoo();
+    }
+
+    private File dbFile;
+
+    protected void getSQLiteConnection() {
+        String tmp = System.getProperty("java.io.tmpdir");
+        assertEquals(tmp,System.getProperty("java.io.tmpdir"));
+        File tmpDir = new File(tmp);
+        try {
+            if (tmpDir.isDirectory()) {
+                dbFile = File.createTempFile("sqliteTest", ".db", tmpDir);
+                dbFile.deleteOnExit();
+            } else {
+                System.err.println("java.io.tmpdir does not exist");
+            }
+            
+            Class.forName("SQLite.JDBCDriver").newInstance();
+            conn = DriverManager.getConnection("jdbc:sqlite:/"
+                    + dbFile.getPath());
+            assertNotNull("Connection created ",conn);
+
+        } catch (IOException e) {
+            System.out.println("Problem creating file " + tmp);
+        } catch (Exception e) {
+            fail("Exception: " + e.toString());
+        }
+    }
+
+    public void tearDown() {
+    Statement st = null;
+        try {
+            if (! conn.isClosed()) {
+            st = conn.createStatement();
+            st.execute("drop table if exists zoo");
+            }
+        } catch (SQLException e) {
+            fail("Couldn't drop table: " + e.getMessage());
+        } finally {
+        try {
+            if (st != null) {
+            st.close();
+                conn.close();
+            }
+                } catch(SQLException ee) {}
+        }
+    }
+
+    public void createZoo() {
+
+        String[] queries = {
+                "create table zoo(id smallint,  name varchar(10), family varchar(10))",
+                "insert into zoo values (1, 'Kesha', 'parrot')",
+                "insert into zoo values (2, 'Yasha', 'sparrow')" };
+        
+    Statement st = null;    
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i]);
+            }
+        } catch (SQLException e) {
+            e.printStackTrace();
+            fail("Unexpected exception: " + e.getMessage());
+        } finally {
+        try {
+            st.close();
+         } catch (SQLException ee) {} 
+    }
+    }
+
+    public void createProcedure() {
+        String proc = "CREATE PROCEDURE welcomeAnimal (IN parameter1 integer, IN parameter2 char(20), IN parameter3 char(20)) "
+                + " BEGIN "
+                + " INSERT INTO zoo(id, name, family) VALUES (parameter1, parameter2, parameter3); "
+                + "SELECT * FROM zoo;" + " END;";
+    Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.execute("DROP PROCEDURE IF EXISTS welcomeAnimal");
+            st.execute(proc);
+        } catch (SQLException e) {
+            fail("Unexpected exception: " + e.getMessage());
+        } finally {
+        try {
+            st.close();
+         } catch (SQLException ee) {} 
+    }
+    }
+
+    public int getCount(ResultSet rs) {
+        int count = 0;
+        try {
+            while (rs.next()) {
+                count++;
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        }
+        return count;
+    }
+}
diff --git a/sql/src/test/java/tests/sql/SavepointTest.java b/sql/src/test/java/tests/sql/SavepointTest.java
new file mode 100644
index 0000000..dedf032
--- /dev/null
+++ b/sql/src/test/java/tests/sql/SavepointTest.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Savepoint;
+
+/**
+ *
+ */
+@TestTargetClass(Savepoint.class)
+public class SavepointTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Savepoint#getSavepointId()}.
+     */
+   @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getSavepointId",
+      args = {}
+      )
+    public void testGetSavepointId() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Savepoint#getSavepointName()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+      method = "getSavepointName",
+      args = {}
+     )
+    public void testGetSavepointName() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/StatementTest.java b/sql/src/test/java/tests/sql/StatementTest.java
new file mode 100755
index 0000000..21560c2
--- /dev/null
+++ b/sql/src/test/java/tests/sql/StatementTest.java
@@ -0,0 +1,1904 @@
+/*
+ * 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.sql.BatchUpdateException;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.SQLWarning;
+import java.sql.Statement;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Vector;
+import java.util.logging.Logger;
+
+@TestTargetClass(Statement.class)
+public class StatementTest extends SQLTest {
+    
+    /**
+     * @test java.sql.Statement#addBatch(String)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "addBatch",
+        args = {java.lang.String.class}
+    )
+    public void testAddBatch() throws SQLException {
+        
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.addBatch("INSERT INTO zoo VALUES (3,'Tuzik','dog')");
+            st.addBatch("INSERT INTO zoo VALUES (4,'Mashka','cat')");
+
+            int[] updateCounts = st.executeBatch();
+            assertEquals(2, updateCounts.length);
+            assertEquals(1, updateCounts[0]);
+            assertEquals(1, updateCounts[1]);
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.addBatch("");
+            st.executeBatch();
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.addBatch(null);
+            st.executeBatch();
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#clearWarnings()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "clearWarnings",
+        args = {}
+    )
+    public void testClearWarnings() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.execute("select animals from zoo");
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        try {
+            st = conn.createStatement();
+            st.clearWarnings();
+            SQLWarning w = st.getWarnings();
+            assertNull(w);
+        } catch (Exception e) {
+            fail("Unexpected Exception: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#getWarnings()
+     * 
+     * TODO getWarnings is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported. always returns null. ",
+        method = "getWarnings",
+        args = {}
+    )
+    public void testGetWarnings() {
+        
+        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 = st.getWarnings();
+            assertNull(wrs);
+        } catch (Exception e) {
+            fail("Change test implementation: get warnings is supported now");
+        }
+        /*
+        Statement st = null;
+        int errorCode1 = -1;
+        int errorCode2 = -1;
+
+        try {
+            st = conn.createStatement();
+            st.execute("select animals from zoooo");
+        } catch (SQLException e) {
+            // expected
+            errorCode1 = e.getErrorCode();
+        }
+        try {
+            SQLWarning wrs = st.getWarnings();
+            assertNull(wrs);
+        } 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 = st.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) {
+        }
+        */
+
+    }
+
+    /**
+     * @test {@link java.sql.Statement#clearBatch()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "clearBatch",
+        args = {}
+    )
+    public void testClearBatch() throws SQLException {
+        
+        Statement st = null;
+        
+        try {
+            st = conn.createStatement();
+            st.addBatch("INSERT INTO zoo VALUES (3,'Tuzik','dog'); ");
+            st.addBatch("INSERT INTO zoo VALUES (4,'Mashka','cat')");
+            
+            st.clearBatch();
+            
+            int[] updateCounts = st.executeBatch();
+            
+            for (int i = 0; i < updateCounts.length; i++) {
+                assertEquals(0, updateCounts[i]);
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.addBatch("");
+            st.executeBatch();
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.addBatch(null);
+            st.executeBatch();
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#execute(String sql)
+     * 
+     * TODO not pass on SQLite and RI.
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "execute",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Return value wrong for queries below.")
+    public void testExecute() throws SQLException {
+
+        String[] queries = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "select animal_id, address from hutch where animal_id=1;",
+                "create view address as select address from hutch where animal_id=2",
+                "drop view address;", "drop table hutch;" };
+        boolean[] results = {false, false, false, false, false, true, false,
+                false, false};
+
+        for (int i = 0; i < queries.length; i++) {
+            Statement st = null;
+            try {
+                st = conn.createStatement();
+                boolean res = st.execute(queries[i]);
+                assertEquals("different result for statement no. "+i, results[i], res);
+            } catch (SQLException e) {
+                fail("SQLException is thrown: " + e.getMessage());
+            } finally {
+                try {
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+        }
+
+        String[] inc_queries = {
+                "update zoo_zoo set name='Masha', family='cat' where id=5;",
+                "drop table hutchNO",
+                "insert into hutch (id, animal_id, address) values (1, 2, 10);",
+                "select animal_id, from hutch where animal_id=1;",
+                "drop view address;", "drop table hutch;", "", null };
+
+        for (int i = 0; i < inc_queries.length; i++) {
+            Statement st = null;
+            try {
+                st = conn.createStatement();
+                st.execute(inc_queries[i]);
+                fail("SQLException is not thrown for query: " + inc_queries[i]);
+            } catch (SQLException e) {
+                // expected
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            } 
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#execute(String sql, int autoGeneratedKeys)
+     * TODO not supported 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Missing implementation for Statement.RETURN_GENERATED_KEYS: keys not yet supported",
+        method = "execute",
+        args = {java.lang.String.class, int.class}
+    )
+   public void testExecute_String_int() {
+        String[] queries = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "select animal_id, address from hutch where animal_id=1;",
+                "create view address as select address from hutch where animal_id=2",
+                "drop view address;", "drop table hutch;" };
+
+        for (int i = 0; i < queries.length; i++) {
+            Statement st = null;
+            try {
+                st = conn.createStatement();
+                st.execute(queries[i], Statement.NO_GENERATED_KEYS);
+                fail("Exception expected: Not supported");
+                /*
+                ResultSet rs = st.getGeneratedKeys();
+                fail("Revise test implemenation for feature impl. has changed");
+                assertFalse(rs.next());
+                */
+            } catch (SQLException e) {
+                // ok
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            } 
+        }
+        
+        for (int i = 0; i < queries.length; i++) {
+            Statement st = null;
+            try {
+                st = conn.createStatement();
+                st.execute(queries[i], Statement.RETURN_GENERATED_KEYS);
+                fail("Exception expected: Not supported");
+                /*
+                ResultSet rs = st.getGeneratedKeys();
+                fail("Revise test implemenation for feature impl. has changed");
+                assertFalse(rs.next());
+                */
+            } catch (SQLException e) {
+                //ok
+            } finally {
+                try {
+                    st.close();
+                } catch (SQLException ee) {
+                }
+            } 
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#getConnection()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "getConnection",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testGetConnection() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            assertSame(conn, st.getConnection());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st.close();
+            st.getConnection();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        
+        
+    }
+
+    /**
+     * @test java.sql.Statement#getFetchDirection()
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "SQLException test fails. Not all Fetch directions supported.",
+        method = "getFetchDirection",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testGetFetchDirection() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            assertEquals(ResultSet.FETCH_UNKNOWN, st.getFetchDirection());
+        } catch (SQLException e) {
+            fail("SQLException is thrown " + e.getMessage());
+        }  finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st = conn.createStatement();
+            st.setFetchDirection(ResultSet.FETCH_FORWARD);
+            assertEquals(ResultSet.FETCH_FORWARD, st.getFetchDirection());
+            fail("Exception expected: not supported");
+        } catch (SQLException e) {
+            // ok
+        }  finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st.getFetchDirection();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#setFetchDirection(int)
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported. ",
+        method = "setFetchDirection",
+        args = {int.class}
+    )
+    public void testSetFetchDirection() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.setFetchDirection(ResultSet.FETCH_FORWARD);
+            st.executeQuery("select * from zoo;");
+            fail("Revise test implemenation for feature impl. has changed");
+//            assertEquals(ResultSet.FETCH_FORWARD, st.getFetchDirection());
+        } catch (SQLException e) {
+//            fail("SQLException is thrown: " + e.getMessage());
+            //ok
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        /*
+        try {
+            st = conn.createStatement();
+            st.setFetchDirection(-1);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        }  finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.setFetchDirection(100);
+            fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        */
+    }
+
+    /**
+     * @test java.sql.Statement#getFetchSize()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "getFetchSize",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testGetFetchSize() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.execute("select * from zoo;");
+            assertEquals(1, st.getFetchSize());
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st.close();
+            st.getFetchSize();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test {@link java.sql.Statement#setFetchSize(int)}
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported.",
+        method = "setFetchSize",
+        args = {int.class}
+    )
+    public void testSetFetchSize() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            int rows = 100;
+            for (int i = 0; i < rows; i++) {
+                try {
+                    st.setFetchSize(i);
+                    assertEquals(i, st.getFetchSize());
+                    fail("Revise: test implemenation for feature impl. has changed");
+                } catch (SQLException sqle) {
+    //                fail("SQLException is thrown: " + sqle.toString());
+                    assertEquals("not supported", sqle.getMessage());
+                }
+            }
+            /*
+            try {
+                st.setFetchSize(-1);
+                fail("SQLException is not thrown");
+            } catch (SQLException sqle) {
+                // expected
+            }
+            */
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#setMaxFieldSize(int max)
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setMaxFieldSize",
+        args = {int.class}
+    )
+    public void testSetMaxFieldSize() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < 300; i += 50) {
+                try {
+                    st.setMaxFieldSize(i);
+                    assertEquals(i, st.getMaxFieldSize());
+                    fail("Revise test implemenation for feature impl. has changed");
+                } catch (SQLException sqle) {
+                    assertEquals("not supported", sqle.getMessage());
+//                    fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+            /*
+            try {
+                st.setMaxFieldSize(-1);
+                fail("SQLException isn't thrown");
+            } catch (SQLException sqle) {
+                // expecteds
+            }
+            */
+        } catch (SQLException e) {
+            fail("Can't create statement, SQLException is thrown: "
+                    + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#getMaxFieldSize()
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxFieldSize",
+        args = {}
+    )
+    public void testGetMaxFieldSize() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            for (int i = 200; i < 500; i += 50) {
+                try {
+                    st.setMaxFieldSize(i);
+                    fail("Revise test implemenation for feature impl. has changed");
+                } catch (SQLException sqle) {
+                    assertEquals("not supported", sqle.getMessage());
+ //                   fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+        } catch (SQLException e) {
+            fail("Can't create statement, SQLException is thrown: "
+                    + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#setMaxRows(int max)
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "setMaxRows",
+        args = {int.class}
+    )
+    public void testSetMaxRows() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.execute("select * from zoo;");
+            for (int i = 0; i < 300; i += 50) {
+                try {
+                    st.setMaxRows(i);
+                    assertEquals(i, st.getMaxRows());
+                    fail("Revise test implemenation for feature impl. has changed");
+                } catch (SQLException sqle) {
+                    assertEquals("not supported", sqle.getMessage());
+//                   fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+            try {
+                st.setMaxRows(-1);
+                fail("SQLException isn't thrown");
+            } catch (SQLException sqle) {
+                // expecteds
+            }
+        } catch (SQLException e) {
+            fail("Can't create statement, SQLException is thrown: "
+                    + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#getMaxRows()
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "getMaxRows",
+        args = {}
+    )
+    public void testGetMaxRows() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            for (int i = 200; i < 500; i += 50) {
+                try {
+                    st.setMaxRows(i);
+                    assertEquals(i, st.getMaxRows());
+                    fail("Revise test implemenation for feature impl. has changed");
+                } catch (SQLException sqle) {
+                    assertEquals("not supported", sqle.getMessage());
+//                    fail("SQLException is thrown: " + sqle.getMessage());
+                }
+            }
+        } catch (SQLException e) {
+            fail("Can't create statement, SQLException is thrown: "
+                    + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#close()
+     * not passed according to Java Docs: should release all resources 
+     * IMMEDIATELY
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "close",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testClose() {
+        Statement st = null;
+        ResultSet res = null;
+        try {
+            String[] queries = {
+                    "update zoo set name='Masha', family='cat' where id=2;",
+                    "insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');",
+                    "insert into zoo (id, name, family) values (4, 'Slon', 'elephant');",
+                    "select * from zoo"};
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i]);
+            }
+            res = st.getResultSet();
+            assertNotNull(res);
+            assertTrue(res.next());
+            st.close();
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        // test release of resources:
+        // this code should throw an exception as the db is not available
+        // anymore in fact every resource which is used afterwards should throw
+        // an SQLException.
+        try {
+            res.next();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            // ok
+        }
+
+    }
+
+    /**
+     * @test java.sql.Statement#execute(String sql, int[] columnIndexes)
+     * TODO not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "execute",
+        args = {java.lang.String.class, int[].class}
+    )
+    public void testExecute_String_intArray() {
+        Statement st = null;
+        try {
+            String[] queries = {
+                    "update zoo set name='Masha', family='cat' where id=2;",
+                    "insert zoo(id, name, family) values (3, 'Vorobey', 'sparrow');",
+                    "insert zoo(id, name, family) values (4, 'Slon', 'elephant');",
+                    "select * from zoo" };
+            Vector<int[]> array = new Vector<int[]>();
+            array.addElement(null);
+            array.addElement(new int[] { 1, 2, 3 });
+            array.addElement(new int[] { 1, 2, 10, 100 });
+            array.addElement(new int[] {});
+
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i], (int[]) array.elementAt(i));
+                fail("SQLException expected: not supported");
+            }
+            /*
+            fail("Revise test implemenation for feature impl. has changed");
+            assertNotNull(st.getResultSet());
+            st.close();
+            assertNull(st.getResultSet());
+            */
+        } catch (SQLException e) {
+            // ok: not supported
+//            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#execute(String sql, String[] columnNames)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "execute",
+        args = {java.lang.String.class, java.lang.String[].class}
+    )
+    public void testExecute_String_StringArray() {
+        Statement st = null;
+        try {
+            String[] queries = {
+                    "update zoo set name='Masha', family='cat' where id=2;",
+                    "insert zoo(id, name, family) values (3, 'Vorobey', 'sparrow');",
+                    "insert zoo(id, name, family) values (4, 'Slon', 'elephant');",
+                    "select * from zoo" };
+            Vector<String[]> array = new Vector<String[]>();
+            array.addElement(null);
+            array.addElement(new String[] { "", "", "", "", "", "", "", "" });
+            array.addElement(new String[] { "field 1", "", "field2" });
+            array.addElement(new String[] { "id", "family", "name" });
+
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.execute(queries[i], (String[]) array.elementAt(i));
+                fail("Exception expected: not supported");
+            }
+            fail("Revise test implemenation for feature impl. has changed");
+            assertNotNull(st.getResultSet());
+            st.close();
+            assertNull(st.getResultSet());
+        } catch (SQLException e) {
+            // ok: not supported
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        } 
+    }
+
+    /**
+     * @test java.sql.Statement#executeBatch()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Test fails: dropping table hutch affects at least 2 rows.executeBatch() always returns same result: 1.",
+        method = "executeBatch",
+        args = {}
+    )
+    @KnownFailure("always returns 1 for no. of updates")
+    public void testExecuteBatch() {
+
+        String[] queries = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "create view address as select address from hutch where animal_id=2",
+                "drop view address;", "drop table hutch;" };
+        
+        String[] wrongQueries = {
+                "update zoo set name='Masha', family='cat' where;",
+                "drop table if exists hutch;",
+                "create view address as select address from hutch where animal_id=2;",
+                "drop view address;", "drop table hutch;" };
+
+        int[] result = { 1, 1, 1, 1, 1, 1, 1, 1 };
+        Statement st = null;
+        
+        //Exception test
+        try {
+            st = conn.createStatement();
+            assertEquals(0, st.executeBatch().length);
+            for (int i = 0; i < wrongQueries.length; i++) {
+                st.addBatch(wrongQueries[i]);
+            }
+            st.executeBatch();
+            fail("BatchupdateException expected");
+        } catch (BatchUpdateException e) {
+            //ok
+        } catch (SQLException e) {
+            fail("BatchupdateException expected");
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        } 
+        
+        try {
+            st = conn.createStatement();
+            assertEquals(0, st.executeBatch().length);
+            for (int i = 0; i < queries.length; i++) {
+                st.addBatch(queries[i]);
+            }
+            int[] resArray = st.executeBatch();
+            assertTrue(java.util.Arrays.equals(result, resArray));
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+
+        try {
+            st = conn.createStatement();
+            st.addBatch("select * from zoo");
+            st.executeBatch();
+            fail("Exception expected");
+        } catch (BatchUpdateException bue) {
+            // ok select returns a resultSet
+        } catch (SQLException sqle) {
+            fail("Unknown SQLException is thrown: " + sqle.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        //Exception test
+        try {
+            st.close();
+            st.executeBatch();
+            fail("SQLException not thrown");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+
+    /**
+     * @test java.sql.Statement#executeQuery(String sql)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Not according to spec.",
+        method = "executeQuery",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Does throw an exception on non select statment.")
+    public void testExecuteQuery_String() {
+
+        String[] queries1 = { "select * from zoo",
+                "select name, family from zoo where id = 1" };
+
+        String[] queries2 = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "create view address as select address from hutch where animal_id=2",
+                "drop view address;", "drop table hutch;", "select from zoo" };
+        
+        Statement st = null;
+        
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < queries1.length; i++) {
+                try {
+                    ResultSet rs = st.executeQuery(queries1[i]);
+                    assertNotNull(rs);
+                } catch (SQLException sqle) {
+                    fail("SQLException is thrown for query: " + queries1[i]);
+                }
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (Exception ee) {
+            }
+        }
+        
+        // queries which do not produce a ResultSet -> exception testing 
+        
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < queries2.length; i++) {
+                try {
+                    ResultSet rs = st.executeQuery(queries2[i]);
+                    assertNotNull(rs);
+                    fail("SQLException is not thrown for query: " + queries2[i]);
+                } catch (SQLException sqle) {
+                    // expected
+                }
+            }
+        } catch (SQLException sqle) {
+            fail("Unknown SQLException is thrown: " + sqle.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (Exception ee) {
+            }
+        } 
+
+    }
+
+    /**
+     * @throws SQLException 
+     * @test java.sql.Statement#executeUpdate(String sql)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "impl not according to spec.",
+        method = "executeUpdate",
+        args = {java.lang.String.class}
+    )
+    @KnownFailure("Spec is not precise enough: should be: number of rows affected."+
+            " eg. to be consistent for deletes: 'delete from s1;' should be different from "+
+            "'delete from s1 where c1 = 1;' ")
+    public void testExecuteUpdate_String() throws SQLException {
+
+        String[] queries1 = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "create view address as select address from hutch where animal_id=2;",
+                "drop view address;", "drop table hutch;"};
+
+        String queries2 = "select * from zoo;";
+
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            for (int i = 0; i < queries1.length; i++) {
+                try {
+                    int count = st.executeUpdate(queries1[i]);
+                    assertTrue(count > 0);
+                } catch (SQLException e) {
+                    fail("SQLException is thrown: " + e.getMessage());
+                }
+            }
+
+            try {
+               assertEquals(0, st.executeUpdate(queries2));
+            } catch (SQLException e) {
+               fail("SQLException is thrown: " + e.getMessage());
+            }
+
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (Exception ee) {
+            }
+        }
+        
+        // test return value for specific numbers 
+        
+        Statement stat = conn.createStatement();
+        
+        // there are 0 rows created therefore 0 should be returned.
+        assertEquals(0 ,stat.executeUpdate("create table s1 (c1);"));
+        
+        assertEquals(1, stat.executeUpdate("insert into s1 values (0);"));
+        assertEquals(1, stat.executeUpdate("insert into s1 values (1);"));
+        assertEquals(1, stat.executeUpdate("insert into s1 values (2);"));
+        assertEquals(1,stat.executeUpdate("delete from s1 where c1 = 1;"));
+        assertEquals(2, stat.executeUpdate("update s1 set c1 = 5;"));
+        
+        // analogous to statemente before, delete all should return 2
+        assertEquals(2,stat.executeUpdate("delete from s1;"));
+        
+        // there are no rows in table: 0 should be returned
+        assertEquals(0, stat.executeUpdate("drop table s1;"));
+        
+        stat.executeUpdate("create table s1 (c1);"); 
+        stat.executeUpdate("insert into s1 values (0);");
+        stat.executeUpdate("insert into s1 values (1);");
+        stat.executeUpdate("insert into s1 values (2);");
+        
+        // there are 3 rows in table: 3 should be returned
+        assertEquals(3, stat.executeUpdate("drop table s1;"));
+        
+        stat.close();
+    }
+
+    /**
+     * @test java.sql.Statement#executeUpdate(String sql, int[] columnIndexes)
+     * 
+     * TODO executeUpdate(String sql, int[] columnIndexes) is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "executeUpdate",
+        args = {java.lang.String.class, int[].class}
+    )
+    public void testExecuteUpdate_String_intArray() {
+        Statement st = null;
+        try {
+            String[] queries1 = {
+                    "update zoo set name='Masha', family='cat' where id=2;",
+                    "drop table if exists hutch",
+                    "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                    "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                    "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                    "create view address as select address from hutch where animal_id=2",
+                    "drop view address;", "drop table hutch;" };
+
+            Vector<int[]> array = new Vector<int[]>();
+            array.addElement(null);
+            array.addElement(new int[] { 1, 2, 3 });
+            array.addElement(new int[] { 1, 2, 10, 100 });
+            array.addElement(new int[] {});
+            array.addElement(new int[] { 100, 200 });
+            array.addElement(new int[] { -1, 0 });
+            array.addElement(new int[] { 0, 0, 0, 1, 2, 3 });
+            array.addElement(new int[] { -100, -200 });
+
+            st = conn.createStatement();
+            for (int i = 0; i < queries1.length; i++) {
+                st.executeUpdate(queries1[i], (int[]) array.elementAt(i));
+                fail("Exception expected");
+            }
+        } catch (SQLException e) {
+            assertEquals("not supported",e.getMessage());
+//            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        } 
+    }
+
+    /**
+     * @test java.sql.Statement#executeUpdate(String sql, int autoGeneratedKeys)
+     * 
+     * TODO  executeUpdate(String sql, int autoGeneratedKeys) is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "executeUpdate",
+        args = {java.lang.String.class, int.class}
+    )
+    public void testExecuteUpdate_String_int() {
+        String[] queries = {
+                "update zoo set name='Masha', family='cat' where id=2;",
+                "drop table if exists hutch",
+                "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                "select animal_id, address from hutch where animal_id=1;",
+                "create view address as select address from hutch where animal_id=2",
+                "drop view address;", "drop table hutch;" };
+
+            Statement st = null;
+            ResultSet rs = null;
+            try {
+                st = conn.createStatement();
+                st.executeUpdate(queries[1], Statement.NO_GENERATED_KEYS);
+                rs = st.getGeneratedKeys();
+                assertFalse(rs.next());
+                fail("Exception expected: not supported");
+            } catch (SQLException e) {
+                //ok
+            } finally {
+                try {
+                    rs.close();
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+            
+            try {
+                st = conn.createStatement();
+                st.executeUpdate(queries[1], Statement.RETURN_GENERATED_KEYS);
+                rs = st.getGeneratedKeys();
+                assertTrue(rs.next());
+                fail("Exception expected: not supported");
+            } catch (SQLException e) {
+                //ok
+            } finally {
+                try {
+                    rs.close();
+                    st.close();
+                } catch (Exception ee) {
+                }
+            }
+    }
+
+    /**
+     * @test java.sql.Statement#executeUpdate(String sql, String[] columnNames)
+     * 
+     * TODO executeUpdate(String sql, String[] columnNames) is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "not supported",
+        method = "executeUpdate",
+        args = {java.lang.String.class, java.lang.String[].class}
+    )
+    public void testExecuteUpdate_String_StringArray() {
+        Statement st = null;
+        try {
+            String[] queries = {
+                    "update zoo set name='Masha', family='cat' where id=2;",
+                    "drop table if exists hutch",
+                    "create table hutch (id integer not null, animal_id integer, address char(20), primary key (id));",
+                    "insert into hutch (id, animal_id, address) values (1, 2, 'Birds-house, 1');",
+                    "insert into hutch (id, animal_id, address) values (2, 1, 'Horse-house, 5');",
+                    "create view address as select address from hutch where animal_id=2",
+                    "drop view address;", "drop table hutch;" };
+
+            Vector<String[]> array = new Vector<String[]>();
+            array.addElement(null);
+            array.addElement(new String[] { "", "", "", "", "", "", "", "" });
+            array.addElement(new String[] { "field 1", "", "field2" });
+            array.addElement(new String[] { "id", "family", "name" });
+            array
+                    .addElement(new String[] { "id", null, "family", null,
+                            "name" });
+            array.addElement(new String[] { "id", " ", "name" });
+            array.addElement(new String[] { null, null, null, null });
+            array.addElement(new String[] { " ", "123 21", "~!@#$%^&*()_+ ",
+                    null });
+
+            st = conn.createStatement();
+            for (int i = 0; i < queries.length; i++) {
+                st.executeUpdate(queries[i], (String[]) array.elementAt(i));
+                fail("Revise test implemenation for feature impl. has changed");
+            }
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+//            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        } 
+    }
+
+    /**
+     * @test java.sql.Statement#getUpdateCount()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "SQLException test fails",
+        method = "getUpdateCount",
+        args = {}
+    )
+    @KnownFailure("statment.close() does not wrap up")
+    public void testGetUpdateCount() {
+        Statement st = null;
+        try {
+            String query = "update zoo set name='Masha', family='cat' where id=2;";
+            st = conn.createStatement();
+            st.executeUpdate(query);
+            assertEquals(1, st.getUpdateCount());
+            query = "update zoo set name='Masha', family='cat' where id=5;";
+            st.executeUpdate(query);
+            assertEquals(0, st.getUpdateCount());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        } 
+        // statment closed : Exception test
+        try {
+            st.getUpdateCount();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getGeneratedKeys()}
+     * 
+     * TODO getGeneratedKeys() is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "getGeneratedKeys",
+        args = {}
+    )
+    public void testGeneratedKeys() {
+        Statement st = null;
+        try {
+            String insert = "insert into zoo (id, name, family) values (8, 'Tuzik', 'dog');";
+            st = conn.createStatement();
+            assertNull(st.getGeneratedKeys());
+            fail("Fail: statement does not fail");
+        } catch (SQLException e) {
+          assertEquals("not supported", e.getMessage());
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#setCursorName(String)}
+     * 
+     * TODO setCursorName() is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "setCursorName",
+        args = {java.lang.String.class}
+    )
+    public void testSetCursorName() {
+        Statement st = null;
+        try {
+            String select = "select * from zoo";
+            st = conn.createStatement();
+            st.setCursorName("test");
+            fail("Fail: statement does not fail");
+        } catch (SQLException e) {
+          assertEquals("not supported", e.getMessage());
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#setEscapeProcessing}
+     * 
+     * TODO setExcapeProcessing() is not supported
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "setEscapeProcessing",
+        args = {boolean.class}
+    )
+    public void testSetEscapeProcessing() {
+        Statement st = null;
+        try {
+            String select = "select * from zoo";
+            st = conn.createStatement();
+            st.setEscapeProcessing(true);
+            fail("Fail: statement does not fail");
+        } catch (SQLException e) {
+          assertEquals("not supported", e.getMessage());
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#setQueryTimeout}
+     * 
+     */
+    @TestTargets({
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Error in impl. default query timeout for sqlite dbs is 0.",
+        method = "setQueryTimeout",
+        args = {int.class}
+    ),
+    @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Error in impl. default query timeout for sqlite dbs is 0.",
+            method = "getQueryTimeout",
+            args = {}
+        )
+    })
+    @KnownFailure("Error in implementation either setter or getter fails. "+
+            "Getter spec is not explicit about unit.")
+    public void testSetQueryTimeout() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.setQueryTimeout(2000);
+            assertEquals(2000, st.getQueryTimeout());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        st = null;
+        try {
+            st = conn.createStatement();
+            st.setQueryTimeout(-1);
+           fail("SQLException is not thrown");
+        } catch (SQLException e) {
+            // expected 
+        }
+        
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getResultSetType()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Tests fail. not fully supported: returns only ResultSet.TYPE_SCROLL_INSENSITIVE. Either should throw an unsupported exception or behave according to spec.",
+        method = "getResultSetType",
+        args = {}
+    )
+    @KnownFailure("not fully supported")
+    public void testGetResultSetType() {
+        Statement st = null;
+        // test default value 
+        try {
+            st = conn.createStatement();
+            st.getResultSetType();
+            assertEquals(ResultSet.TYPE_SCROLL_INSENSITIVE, st
+                    .getResultSetType());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+
+        // failing tests
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
+                    ResultSet.CONCUR_UPDATABLE);
+            st.getResultSetType();
+            assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, st.getResultSetType());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
+                    ResultSet.CONCUR_UPDATABLE);
+            st.getResultSetType();
+            assertEquals(ResultSet.TYPE_SCROLL_SENSITIVE, st.getResultSetType());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+
+        try {
+            st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_UPDATABLE);
+            st.getResultSetType();
+            assertEquals(ResultSet.TYPE_FORWARD_ONLY, st.getResultSetType());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getResultSetHoldability()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not supported",
+        method = "getResultSetHoldability",
+        args = {}
+    )
+    @KnownFailure("Test for default value fails")
+    public void testGetResultSetHoldability() {
+        
+        // test default value 
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, st
+                    .getResultSetHoldability());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+
+        // failing tests
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
+                    ResultSet.CONCUR_READ_ONLY,
+                    ResultSet.HOLD_CURSORS_OVER_COMMIT);
+            fail("Exception expected: not supported");
+            /*
+            st.getResultSetHoldability();
+            assertEquals(ResultSet.HOLD_CURSORS_OVER_COMMIT, st
+                    .getResultSetHoldability());
+            */
+        } catch (SQLException e) {
+            // ok: not supported
+        }
+
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
+                    ResultSet.CONCUR_READ_ONLY,
+                    ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            fail("Exception expected: not supported");
+            /*
+            st.getResultSetHoldability();
+            assertEquals(ResultSet.CLOSE_CURSORS_AT_COMMIT, st
+                    .getResultSetHoldability());
+            */
+        } catch (SQLException e) {
+         // ok: not supported
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getResultSetConcurrency()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "Tests fail. returns only ResultSet.TYPE_SCROLL_INSENSITIVE. Either should throw an unsupported exception or behave according to spec.",
+        method = "getResultSetConcurrency",
+        args = {}
+    )
+    @KnownFailure("Not supported")
+    public void testGetResultSetConcurrency() {
+        Statement st = null;
+        
+        // test default value 
+        try {
+            st = conn.createStatement();
+            st.getResultSetConcurrency();
+            assertEquals(ResultSet.CONCUR_READ_ONLY, st
+                    .getResultSetConcurrency());
+        } catch (SQLException e) {
+            assertEquals("not supported", e.getMessage());
+        }
+       
+     // failing tests
+
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+                    ResultSet.CONCUR_UPDATABLE);
+            st.getResultSetConcurrency();
+            assertEquals(ResultSet.CONCUR_UPDATABLE, st.getResultSetConcurrency());
+            fail("Exception expected: not supported");
+        } catch (SQLException e) {
+            //ok
+       
+        }
+        
+        try {
+            st = conn.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
+                    ResultSet.CONCUR_READ_ONLY);
+            st.getResultSetConcurrency();
+            assertEquals(ResultSet.CONCUR_READ_ONLY, st.getResultSetConcurrency());
+            fail("Exception expected: not supported");
+        } catch (SQLException e) {
+            //ok;
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getResultSet()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Error in implementation. Is not according to spec:if updateCount > 0 resultset must be null.",
+        method = "getResultSet",
+        args = {}
+    )
+    @KnownFailure("Does not return null on update count > 0 (not a select statement) ")
+    public void testGetResultSet() {
+        Statement st = null;
+        ResultSet res = null;
+        
+        try {
+            st = conn.createStatement(ResultSet.TYPE_FORWARD_ONLY,
+                    ResultSet.CONCUR_READ_ONLY,
+                    ResultSet.CLOSE_CURSORS_AT_COMMIT);
+            st.execute("create table test (c1);");
+            res = st.getResultSet();
+            assertNull(res);
+        } catch (SQLException e) {
+            fail("Unexpected Exception "+e);
+        }
+        
+        try {
+            st = conn.createStatement();
+            String select = "select * from zoo where id == 4;";
+            String insert =  "insert into zoo (id, name, family) values (4, 'Vorobuy', 'bear');";
+            st.execute(insert);
+            st.execute(select);
+            assertEquals(-1, st.getUpdateCount());
+            res = st.getResultSet();
+            assertNotNull(res);
+            res.next();
+            assertEquals(4,res.getInt(1));
+            assertEquals("Vorobuy",res.getString(2));
+            assertEquals("bear",res.getString(3));
+//            assertEquals(0, st.getUpdateCount()); not supported            
+            assertFalse(res.next());
+        } catch (SQLException e) {
+            fail("SQLException is thrown:"+e.getMessage());
+        }
+        
+        try {
+            st = conn.createStatement();
+            String insert = "insert into zoo (id, name, family) values (3, 'Vorobey', 'sparrow');";
+            st
+            .execute(insert);
+            res = st.getResultSet();
+            // statement is an update and should return null according to spec. 
+            if (st.getUpdateCount() > 0)  {
+                assertNull(res);
+            }
+           
+        } catch (SQLException e) {
+            fail("SQLException is thrown:"+e.getMessage());
+        }
+        
+        try {
+            st.close();
+            st.getResultSet();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#setQueryTimeout}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Errors in impl.An other value is returned than was set (X * 1000)Default query timeout for sqlite dbs is 0.",
+        method = "getQueryTimeout",
+        args = {}
+    )
+    @KnownFailure("An other value is returned than was set (X * 1000)")
+    public void testGetQueryTimeout() {
+        Statement st = null;
+        try {
+            st = conn.createStatement();
+            st.setQueryTimeout(2000);
+            assertEquals(2000, st.getQueryTimeout());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            st = conn.createStatement();
+            assertEquals(0,st.getQueryTimeout());
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            st.close();
+            st.getQueryTimeout();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getMoreResults()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.SUFFICIENT,
+        notes = "not fully supported",
+        method = "getMoreResults",
+        args = {}
+    )
+    @KnownFailure("not supported")
+    public void testGetMoreResults() {
+        Statement st = null;
+        ResultSet res1 = null;
+        ResultSet res2 = null;
+        String[] queries = {
+                "insert into zoo values (3,'John','bird');",
+                "update zoo set name='Masha', family='cat' where id=3;",
+                "update zoo set name='Masha', family='bear' where id=3;"};
+        
+       try {
+            st = conn.createStatement();
+            st.execute(queries[0]);
+            assertFalse(st.getMoreResults());
+ 
+            try {
+                st.getResultSet();
+                fail("Exception expected");
+            } catch (SQLException e) {
+                //ok
+            }
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st.getMoreResults();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#getMoreResults(int)}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.NOT_FEASIBLE,
+        notes = "Callable Statements are not supported",
+        method = "getMoreResults",
+        args = {int.class}
+    )
+    public void testGetMoreResultsInt() {
+        /*
+        } catch (BatchUpdateException e) {
+            fail("Unexpected Exception "+e.getMessage());
+        } catch (SQLException e) {
+            assertEquals("not supported",e.getMessage());
+        } finally {
+            try {
+                st.close();
+            } catch (SQLException ee) {
+            }
+        }
+        
+        try {
+            st.getMoreResults(Integer.MAX_VALUE);
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+        */
+    }
+    
+    /**
+     * @test {@link java.sql.Statement#cancel()}
+     * 
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Test fails. See also SQLite.DatabaseTest test of interrupt().",
+        method = "cancel",
+        args = {}
+    )
+    @KnownFailure("Bug in implementation of cancel: Does not fulfill spec.")
+    public void testCancel() {
+        Statement st = null;
+        try {
+            st = conn.prepareStatement("insert into zoo values (7,'Speedy Gonzales','Mouse');");
+            
+            CancelThread c = new CancelThread(st);
+            InsertThread ins = new InsertThread((PreparedStatement)st);
+            
+            try {
+                ins.t.join();
+                c.t.join();
+            } catch (InterruptedException e) {
+                fail("Error in test setup: ");
+            } catch (Exception e){
+                // Insert thread may throw an exception 
+                // that it could not complete statement
+            }
+            
+            // both threads have terminated and cancel should have cancelled the insert statement.
+            ResultSet res = st.executeQuery("select * from zoo where id=7");
+            assertFalse(res.next());
+            
+        } catch (SQLException e) {
+            fail("SQLException is thrown: " + e.getMessage());
+        }
+        
+        try {
+            st.close();
+            st.cancel();
+            fail("Exception expected");
+        } catch (SQLException e) {
+            //ok
+        }
+    }
+    
+    class CancelThread implements Runnable{
+        Thread t;
+        Statement stmt;
+        CancelThread (Statement aSt) {
+           this.stmt = aSt;
+           t = new Thread(this,"Cancel thread");
+           t.start();
+        }
+        public void run() {
+           Logger.global.info("*Cancel* thread started");
+           try {
+             Thread.sleep(1500);
+         } catch (InterruptedException e1) {
+             fail("Error in test setup");
+             e1.printStackTrace();
+         }             
+           try {
+               Logger.global.info("*Cancel* thread, about to do stmt.cancel()");  
+               stmt.cancel();
+               Logger.global.info("*Cancel* thread, stmt.cancel() done");  
+           } catch (SQLException e) {
+               fail("Error in test setup");
+               e.printStackTrace();
+           }
+           Logger.global.info("*Cancel* thread terminated");
+        }
+     }
+    
+    class InsertThread implements Runnable{
+        Thread t;
+        PreparedStatement stmt;
+        InsertThread (PreparedStatement aSt) {
+           this.stmt = aSt;
+           t = new Thread(this,"Insert thread");
+           t.start();
+        }
+        public void run() {
+          Logger.global.info("*Insert* thread started");
+           try {
+             Thread.sleep(1500);
+         } catch (InterruptedException e1) {
+             fail("Error in test setup");
+             e1.printStackTrace();
+         }             
+           try {
+               Logger.global.info("*Insert* thread, about to do insertion");  
+               stmt.execute();
+               stmt.execute();
+               Logger.global.info("*Insert* thread inserted");  
+           } catch (SQLException e) {
+               fail("Error in test setup");
+               e.printStackTrace();
+           }
+          Logger.global.info("*Insert* thread terminated");
+        }
+     }
+
+}
diff --git a/sql/src/test/java/tests/sql/StructTest.java b/sql/src/test/java/tests/sql/StructTest.java
new file mode 100644
index 0000000..2f6748b
--- /dev/null
+++ b/sql/src/test/java/tests/sql/StructTest.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2008 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.TestLevel;
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
+
+import junit.framework.TestCase;
+
+import java.sql.Struct;
+import java.util.Map;
+
+/**
+ * @author andrea@google.com (Your Name Here)
+ *
+ */
+@TestTargetClass(Struct.class)
+public class StructTest extends TestCase {
+
+    /**
+     * Test method for {@link java.sql.Struct#getSQLTypeName()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getSQLTypeName",
+          args = {}
+        
+    )
+    public void testGetSQLTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Struct#getAttributes()}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+        
+          method = "getAttributes",
+          args = {}
+    )
+    public void testGetAttributes() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * Test method for {@link java.sql.Struct#getAttributes(java.util.Map)}.
+     */
+    @TestTargetNew(
+      level = TestLevel.NOT_FEASIBLE,
+      notes = "",
+          method = "getAttributes",
+          args = {Map.class}
+    )
+    public void testGetAttributesMapOfStringClassOfQ() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/support/DatabaseCreator.java b/sql/src/test/java/tests/support/DatabaseCreator.java
new file mode 100755
index 0000000..12744dd
--- /dev/null
+++ b/sql/src/test/java/tests/support/DatabaseCreator.java
@@ -0,0 +1,401 @@
+/*
+ * 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.support;
+
+import java.sql.Connection;
+import java.sql.Date;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.sql.Time;
+
+public class DatabaseCreator {
+    public static final int defaultInt = 2;
+
+    public static final String defaultString = "string";
+
+    public static final String defaultCharacter = "chr";
+
+    public static final double defaultDouble = 0.1;
+
+    public static final String TEST_TABLE1 = "table1";
+
+    public static final String TEST_TABLE2 = "table2";
+
+    public static final String TEST_TABLE3 = "table3";
+
+    public static final String TEST_TABLE4 = "table4";
+
+    public static final String SALESPEOPLE_TABLE = "Salespeople";
+
+    public static final String CUSTOMERS_TABLE = "Customers";
+
+    public static final String ORDERS_TABLE = "Orders";
+
+    public static final String PARENT_TABLE = "test_names";
+
+    public static final String FKSTRICT_TABLE = "test_strict";
+
+    public static final String FKCASCADE_TABLE = "test_cascade";
+
+    public static final String TEST_TABLE5 = "test";
+
+    public static final String SIMPLE_TABLE1 = "simple_table1";
+
+    public static final String SIMPLE_TABLE2 = "simple_table2";
+
+    public static final String SIMPLE_TABLE3 = "simple_table3";
+
+    public static final String CREATE_TABLE1 = "CREATE TABLE " + TEST_TABLE1
+            + " (id INTEGER NOT NULL," + " field1 CHAR(100) DEFAULT NULL,"
+            + " field2 DECIMAL " //+ defaultInt
+            + " COMMENT 'field2_rem'," + " field3 DECIMAL," + " fkey INTEGER,"
+            + " PRIMARY KEY (id) FOREIGN KEY (fkey) REFERENCES "
+            + TEST_TABLE3 + "(fk))";
+
+    public static final String CREATE_TABLE2 = "CREATE TABLE " + TEST_TABLE2
+            + " ( " + "finteger integer NOT NULL, " + "ftext text, "
+            + "fcharacter character (5), " + "fdecimal decimal (5,1), "
+            + "fnumeric numeric (4,1), " + "fsmallint smallint, "
+            + "ffloat float, " + "freal real, " + "fdouble double, "
+            + "fdate date," + " ftime time, PRIMARY KEY (finteger))";
+
+    public static final String CREATE_TABLE3 = "CREATE TABLE " + TEST_TABLE3
+            + " (fk INTEGER NOT NULL," + "" + " PRIMARY KEY (fk))";
+
+    public static final String CREATE_TABLE4 = "CREATE TABLE " + TEST_TABLE4
+            + " (fk INTEGER NOT NULL," + " field1 CHAR(100) NOT NULL,"
+            + " PRIMARY KEY (fk))";
+
+    public static final String CREATE_TABLE5 = "CREATE TABLE " + TEST_TABLE5
+            + "( testId INTEGER NOT NULL, testValue CHAR(200))";
+
+    public static final String CREATE_TABLE_SALESPEOPLE = "CREATE TABLE "
+            + SALESPEOPLE_TABLE + " (snum integer, sname character (10),"
+            + " city character (10), comm real, PRIMARY KEY (snum))";
+
+    public static final String CREATE_TABLE_CUSTOMERS = "CREATE TABLE "
+            + CUSTOMERS_TABLE
+            + " (cnum integer, cname character (10), city character (10),"
+            + " rating integer, snum integer, PRIMARY KEY (cnum))";
+
+    public static final String CREATE_TABLE_ORDERS = "CREATE TABLE "
+            + ORDERS_TABLE
+            + " (onum integer, amt real, odate date, cnum integer,"
+            + " snum integer, PRIMARY KEY (onum))";
+
+    public static final String CREATE_TABLE_PARENT = "CREATE TABLE "
+            + PARENT_TABLE + "(id INTEGER NOT NULL, "
+            + "name CHAR(200), PRIMARY KEY(id))";
+
+    public static final String CREATE_TABLE_FKSTRICT = "CREATE TABLE "
+            + FKSTRICT_TABLE + "(id INTEGER NOT NULL," + "name_id INTEGER,"
+            + "value CHAR(200), PRIMARY KEY(id), "
+            + "CONSTRAINT fk1 FOREIGN KEY (name_id) " + "REFERENCES "
+            + PARENT_TABLE + " (id) " + "ON DELETE RESTRICT "
+            + "ON UPDATE RESTRICT)";
+
+    public static final String CREATE_TABLE_FKCASCADE = "CREATE TABLE "
+            + FKCASCADE_TABLE + "(id INTEGER NOT NULL," + "name_id INTEGER,"
+            + "value CHAR(200), PRIMARY KEY(id), "
+            + "CONSTRAINT fk2 FOREIGN KEY (name_id) " + "REFERENCES "
+            + PARENT_TABLE + " (id) " + "ON DELETE CASCADE "
+            + "ON UPDATE CASCADE)";
+
+    public static final String CREATE_TABLE_SIMPLE1 = "CREATE TABLE "
+            + SIMPLE_TABLE1 + "(id INTEGER NOT NULL," + "speed INTEGER,"
+            + "size INTEGER)";
+
+    public static final String CREATE_TABLE_SIMPLE2 = "CREATE TABLE "
+            + SIMPLE_TABLE2 + "(id INTEGER NOT NULL," + "speed INTEGER,"
+            + "size INTEGER)";
+
+    public static final String CREATE_TABLE_SIMPLE3 = "CREATE TABLE "
+            + SIMPLE_TABLE3 + "(id INTEGER NOT NULL," + "speed INTEGER)";
+
+    public static final String DROP_TABLE1 = "DROP TABLE " + TEST_TABLE1;
+
+    public static final String DROP_TABLE2 = "DROP TABLE " + TEST_TABLE2;
+
+    public static final String DROP_TABLE3 = "DROP TABLE " + TEST_TABLE3;
+
+    public static final String DROP_TABLE4 = "DROP TABLE " + TEST_TABLE4;
+
+    public static final String DROP_TABLE5 = "DROP TABLE " + TEST_TABLE5;
+
+    public static final String DROP_TABLE_CUSTOMERS = "DROP TABLE "
+            + CUSTOMERS_TABLE;
+
+    public static final String DROP_TABLE_ORDERS = "DROP TABLE " + ORDERS_TABLE;
+
+    public static final String DROP_TABLE_SALESPEOPLE = "DROP TABLE "
+            + SALESPEOPLE_TABLE;
+
+    public static final String DROP_TABLE_PARENT = "DROP TABLE " + PARENT_TABLE;
+
+    public static final String DROP_TABLE_FKSTRICT = "DROP TABLE "
+            + FKSTRICT_TABLE;
+
+    public static final String DROP_TABLE_FKCASCADE = "DROP TABLE "
+            + FKCASCADE_TABLE;
+
+    public static final String DROP_TABLE_SIMPLE1 = "DROP TABLE "
+            + SIMPLE_TABLE1;
+
+    public static final String DROP_TABLE_SIMPLE2 = "DROP TABLE "
+            + SIMPLE_TABLE2;
+
+    public static final String DROP_TABLE_SIMPLE3 = "DROP TABLE "
+            + SIMPLE_TABLE3;
+
+    public static final String INSERT_SALESPEOPLE1 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1001, 'Peel', 'London', .12)";
+
+    public static final String INSERT_SALESPEOPLE2 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1002, 'Serres', 'SanJose', .13)";
+
+    public static final String INSERT_SALESPEOPLE3 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1004, 'Motika', 'London', .11)";
+
+    public static final String INSERT_SALESPEOPLE4 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1007, 'Rifkin', 'Barcelona', .15)";
+
+    public static final String INSERT_SALESPEOPLE5 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1003, 'Axelrod', 'NewYork', .10)";
+
+    public static final String INSERT_SALESPEOPLE6 = " INSERT INTO "
+            + SALESPEOPLE_TABLE + " (snum, sname, city, comm) "
+            + "VALUES (1013, 'Simpson', 'Kasan', .25)";
+
+    public static final String INSERT_CUSTOMERS1 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum)"
+            + " VALUES (2001, 'Hoffman', 'London', 100, 1001)";
+
+    public static final String INSERT_CUSTOMERS2 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2002, 'Giovanni', 'Rome', 200, 1003)";
+
+    public static final String INSERT_CUSTOMERS3 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2003, 'Liu', 'SanJose', 200, 1002)";
+
+    public static final String INSERT_CUSTOMERS4 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2004, 'Grass', 'Berlin', 300, 1002)";
+
+    public static final String INSERT_CUSTOMERS5 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2006, 'Clemens', 'London', 100, 1001)";
+
+    public static final String INSERT_CUSTOMERS6 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2008, 'Cisneros', 'SanJose', 300, 1007)";
+
+    public static final String INSERT_CUSTOMERS7 = " INSERT INTO "
+            + CUSTOMERS_TABLE + " (cnum, cname, city, rating, snum) "
+            + "VALUES (2007, 'Pereira', 'Rome', 100, 1004)";
+
+    public static final String INSERT_ORDERS1 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3001, 18.69, 10/03/1990, 2008, 1007)";
+
+    public static final String INSERT_ORDERS2 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3003, 767.19, 10/03/1990, 2001, 1001)";
+
+    public static final String INSERT_ORDERS3 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3002, 1900.10, 10/03/1990, 2007, 1004)";
+
+    public static final String INSERT_ORDERS4 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3005, 5160.45, 10/03/1990, 2003, 1002)";
+
+    public static final String INSERT_ORDERS5 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3006, 1098.16, 10/03/1990, 2008, 1007)";
+
+    public static final String INSERT_ORDERS6 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3009, 1713.23, 10/04/1990, 2002, 1003)";
+
+    public static final String INSERT_ORDERS7 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3007, 75.75, 10/04/1990, 2004, 1002)";
+
+    public static final String INSERT_ORDERS8 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3008, 4723.01, 10/05/1990, 2006, 1001)";
+
+    public static final String INSERT_ORDERS9 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3010, 1309.95, 10/06/1990, 2004, 1002)";
+
+    public static final String INSERT_ORDERS10 = " INSERT INTO " + ORDERS_TABLE
+            + " (onum, amt, odate, cnum, snum) "
+            + "VALUES (3011, 9891.88, 10/06/1990, 2006, 1001)";
+
+    public static void fillParentTable(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement
+                .execute("INSERT INTO " + PARENT_TABLE + " VALUES(1, 'test1')");
+        statement.execute("INSERT INTO " + PARENT_TABLE + " VALUES(2,'test2')");
+        statement
+                .execute("INSERT INTO " + PARENT_TABLE + " VALUES(3, 'test3')");
+    }
+
+    public static void fillFKStrictTable(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement.execute("INSERT INTO " + FKSTRICT_TABLE
+                + " VALUES(1, 1, '1')");
+        statement.execute("INSERT INTO " + FKSTRICT_TABLE
+                + " VALUES(2, 2, '2')");
+        statement.execute("INSERT INTO " + FKSTRICT_TABLE
+                + " VALUES(3, 1, '3')");
+    }
+
+    public static void fillFKCascadeTable(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement.execute("INSERT INTO " + FKCASCADE_TABLE
+                + " VALUES(1, 1, '1')");
+        statement.execute("INSERT INTO " + FKCASCADE_TABLE
+                + " VALUES(2, 2, '2')");
+        statement.execute("INSERT INTO " + FKCASCADE_TABLE
+                + " VALUES(3, 1, '3')");
+    }
+
+    public static void fillSimpleTable1(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement
+                .execute("INSERT INTO " + SIMPLE_TABLE1 + " VALUES(1, 10, 20)");
+        statement.execute("INSERT INTO " + SIMPLE_TABLE1 + " VALUES(2, 5, 7)");
+    }
+
+    public static void fillSimpleTable3(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement.execute("INSERT INTO " + SIMPLE_TABLE3 + " VALUES(1, 8)");
+        statement.execute("INSERT INTO " + SIMPLE_TABLE3 + " VALUES(2, 6)");
+        statement.execute("INSERT INTO " + SIMPLE_TABLE3 + " VALUES(3, 4)");
+    }
+
+    public static void fillSalesPeopleTable(Connection conn)
+            throws SQLException {
+        Statement statement = conn.createStatement();
+
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE1);
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE2);
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE3);
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE4);
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE5);
+        statement.execute(DatabaseCreator.INSERT_SALESPEOPLE6);
+    }
+
+    public static void fillCustomersTable(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS1);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS2);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS3);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS4);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS5);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS6);
+        statement.execute(DatabaseCreator.INSERT_CUSTOMERS7);
+    }
+
+    public static void fillOrdersTable(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+
+        statement.execute(DatabaseCreator.INSERT_ORDERS1);
+        statement.execute(DatabaseCreator.INSERT_ORDERS2);
+        statement.execute(DatabaseCreator.INSERT_ORDERS3);
+        statement.execute(DatabaseCreator.INSERT_ORDERS4);
+        statement.execute(DatabaseCreator.INSERT_ORDERS5);
+        statement.execute(DatabaseCreator.INSERT_ORDERS6);
+        statement.execute(DatabaseCreator.INSERT_ORDERS7);
+        statement.execute(DatabaseCreator.INSERT_ORDERS8);
+        statement.execute(DatabaseCreator.INSERT_ORDERS9);
+        statement.execute(DatabaseCreator.INSERT_ORDERS10);
+    }
+
+    public static void fillTestTable1(Connection conn, int numberOfRecords)
+            throws SQLException {
+        Statement statement = conn.createStatement();
+        for (int id = 0; id < numberOfRecords; id++) {
+            String value = DatabaseCreator.defaultString + id;
+            String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE1
+                    + " (id, field1, field2, field3) VALUES(" + id + ", '"
+                    + value + "', " + id + ", " + id + ")";
+            statement.execute(insertQuery);
+        }
+    }
+
+    public static void fillTestTable2(Connection conn, int startID, int endID,
+            long time) throws SQLException {
+        Statement statement = conn.createStatement();
+        for (int id = startID; id <= endID; id++) {
+            double value = id + DatabaseCreator.defaultDouble;
+            String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE2
+                    + " (finteger, ftext, fcharacter, fdecimal, fnumeric,"
+                    + " fsmallint, ffloat, freal, fdouble, fdate, ftime)"
+                    + " VALUES (" + id + ", '" + DatabaseCreator.defaultString
+                    + id + "'," + " '" + DatabaseCreator.defaultCharacter + id
+                    + "', " + value + ", " + value + "," + value + ", " + value
+                    + ", " + value + "," + value + ", '"
+                    + new Date(time).toString() + "'," + " '"
+                    + new Time(time).toString() + "')";
+            statement.execute(insertQuery);
+        }
+    }
+
+    public static void fillTestTable2(Connection conn, int numberOfRecords)
+            throws SQLException {
+        Statement statement = conn.createStatement();
+        for (int id = 0; id < numberOfRecords; id++) {
+            double value = id + DatabaseCreator.defaultDouble;
+            String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE2
+                    + " (finteger, ftext, fcharacter, fdecimal, fnumeric,"
+                    + " fsmallint, ffloat, freal, fdouble)" + " VALUES (" + id
+                    + ", '" + DatabaseCreator.defaultString + id + "'," + " '"
+                    + DatabaseCreator.defaultCharacter + id + "', " + value
+                    + ", " + value + "," + value + ", " + value + ", " + value
+                    + "," + value + ")";
+            statement.execute(insertQuery);
+        }
+    }
+
+    public static void fillTestTable4(Connection conn, int numberOfRecords)
+            throws SQLException {
+        Statement statement = conn.createStatement();
+        for (int id = 0; id < numberOfRecords; id++) {
+            String insertQuery = "INSERT INTO " + DatabaseCreator.TEST_TABLE4
+                    + " (fk, field1) VALUES(" + id + ", \""
+                    + DatabaseCreator.defaultString + id + "\")";
+            statement.execute(insertQuery);
+        }
+    }
+
+    public static void fillTestTable5(Connection conn) throws SQLException {
+        Statement statement = conn.createStatement();
+        statement.execute("INSERT INTO " + TEST_TABLE5 + " VALUES(1, '0')");
+        statement.execute("INSERT INTO " + TEST_TABLE5 + " VALUES(2, '3')");
+        statement.execute("INSERT INTO " + TEST_TABLE5 + " VALUES(3, '4')");
+    }
+}
diff --git a/sql/src/test/java/tests/support/MockCallback.java b/sql/src/test/java/tests/support/MockCallback.java
new file mode 100644
index 0000000..c605c38
--- /dev/null
+++ b/sql/src/test/java/tests/support/MockCallback.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright (C) 2008 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.support;
+
+import SQLite.Callback;
+
+
+public class MockCallback implements Callback {
+
+    public void columns(String cols[]) {
+        System.out.println("&lt;TH&gt;&lt;TR&gt;");
+        for (int i = 0; i <= cols.length; i++) {
+            System.out.println("&lt;TD&gt;" + cols[i] + "&lt;/TD&gt;");
+        }
+        System.out.println("&lt;/TR&gt;&lt;/TH&gt;");
+    }
+
+    public boolean newrow(String cols[]) {
+        System.out.println("&lt;TR&gt;");
+        for (int i = 0; i <= cols.length; i++) {
+            System.out.println("&lt;TD&gt;" + cols[i] + "&lt;/TD&gt;");
+        }
+        System.out.println("&lt;/TR&gt;");
+        return false;
+    }
+
+    public void types(String[] types) {
+        // TODO Auto-generated method stub
+
+    }
+}
diff --git a/sql/src/test/java/tests/support/MockFunction.java b/sql/src/test/java/tests/support/MockFunction.java
new file mode 100644
index 0000000..de4e9f5
--- /dev/null
+++ b/sql/src/test/java/tests/support/MockFunction.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright (C) 2008 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.support;
+
+import SQLite.Function;
+import SQLite.FunctionContext;
+
+
+public class MockFunction implements SQLite.Function{
+    private StringBuffer acc = new StringBuffer();
+    public static boolean getAggValueCalled = false;
+    public static boolean functionCalled = false;
+    public static boolean stepCalled = false;
+    public static boolean lastStepCalled = false;
+    
+    public String getAggValue() {
+        getAggValueCalled = true;
+        return acc.toString();
+    }
+    
+    public void function(FunctionContext fc, String args[]) {
+        functionCalled = true;
+        if (args.length > 0) {
+            fc.set_result(args[0].toLowerCase());
+        }
+    }
+
+    public void step(FunctionContext fc, String args[]) {
+        stepCalled = true;
+        for (int i = 0; i < args.length; i++) {
+            acc.append(args[i]);
+            acc.append(" ");
+        }
+    }
+
+    public void last_step(FunctionContext fc) {
+        lastStepCalled = true;
+        fc.set_result(acc.toString());
+    }
+}
\ No newline at end of file
diff --git a/sql/src/test/java/tests/support/Support_SQL.java b/sql/src/test/java/tests/support/Support_SQL.java
new file mode 100644
index 0000000..1f63f15
--- /dev/null
+++ b/sql/src/test/java/tests/support/Support_SQL.java
@@ -0,0 +1,111 @@
+/*
+ * 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.support;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.SQLException;
+import java.util.Properties;
+
+public class Support_SQL {
+
+    public static String sqlDriver = null;
+
+    public static String sqlLogin = null;
+
+    public static String sqlCatalog = null;
+
+    public static String sqlHost = null;
+
+    public static String sqlUrl = null;
+
+    public static String sqlPassword = null;
+
+    public static String sqlUser = null;
+
+    public static int sqlMaxConnections = 5;
+
+    public static int sqlMaxTasks = 1;
+    
+    private static File dbFile = null;
+
+    public static void loadDriver() {
+        try {
+            loadProperties(Class.forName("tests.support.Support_SQL")
+                    .getResourceAsStream("/connection.properties"));
+
+            String tmp = System.getProperty("java.io.tmpdir");
+            File tmpDir = new File(tmp);
+            if (tmpDir.isDirectory()) {
+                dbFile = File.createTempFile("sqliteTest", ".db", tmpDir);
+                dbFile.deleteOnExit();
+            } else {
+                System.err.println("java.io.tmpdir does not exist");
+            }
+            Class.forName("SQLite.JDBCDriver").newInstance();
+
+            // overwrite sqlUrl to point to valid directory
+            sqlUrl = "jdbc:sqlite:/" + dbFile.getPath();
+
+            Class.forName(sqlDriver).newInstance();
+        } catch (Exception ex) {
+            System.err.println("Unexpected exception " + ex.toString());
+        }
+    }
+
+    public static Connection getConnection() throws SQLException {
+        return DriverManager.getConnection(Support_SQL.sqlUrl,
+                Support_SQL.sqlLogin, Support_SQL.sqlPassword);
+    }
+
+    public static Connection getConnection(String url, String login,
+            String password) throws SQLException {
+
+        return DriverManager.getConnection(url, login, password);
+    }
+
+    public static boolean isEqual(byte[] b1, int off1, byte[] b2, int off2,
+            int len) {
+        for (int i = 0; i < len; ++i)
+            if (b1[i + off1] != b2[i + off2])
+                return false;
+        return true;
+    }
+
+    private static void loadProperties(InputStream fileName) throws IOException {
+        Properties properties = new Properties();
+        properties.load(fileName);
+        sqlDriver = properties.getProperty("sqlDriver");
+        sqlLogin = properties.getProperty("sqlLogin");
+        sqlCatalog = properties.getProperty("sqlCatalog");
+        sqlHost = properties.getProperty("sqlHost");
+        sqlUrl = properties.getProperty("sqlUrlPrefix") + sqlHost + "/"
+                + sqlCatalog;
+        sqlPassword = properties.getProperty("sqlPassword");
+        sqlUser = properties.getProperty("sqlUser");
+        sqlMaxConnections = Integer.parseInt(properties
+                .getProperty("sqlMaxConnections"));
+        sqlMaxTasks = Integer.parseInt(properties.getProperty("sqlMaxTasks"));
+    }
+    
+    public static String getFilename() {
+        return dbFile.getPath();
+    }
+}
diff --git a/sql/src/test/java/tests/support/ThreadPool.java b/sql/src/test/java/tests/support/ThreadPool.java
new file mode 100644
index 0000000..6e82f25
--- /dev/null
+++ b/sql/src/test/java/tests/support/ThreadPool.java
@@ -0,0 +1,120 @@
+/*
+ * 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.support;
+
+import java.util.LinkedList;
+import java.util.logging.Logger;
+
+public class ThreadPool extends ThreadGroup {
+
+    private boolean isAlive;
+
+    private LinkedList<Runnable> taskQueue;
+
+    private int threadID;
+
+    private static int threadPoolID;
+
+    public ThreadPool(int numThreads) {
+        super("ThreadPool-" + (threadPoolID++));
+        setDaemon(true);
+
+        isAlive = true;
+
+        taskQueue = new LinkedList<Runnable>();
+        for (int i = 0; i < numThreads; i++) {
+            new PooledThread().start();
+        }
+    }
+
+    public synchronized void runTask(Runnable task) {
+        if (!isAlive) {
+            throw new IllegalStateException();
+        }
+        if (task != null) {
+            taskQueue.add(task);
+            notify();
+        }
+    }
+
+    protected synchronized Runnable getTask() throws InterruptedException {
+        while (taskQueue.size() == 0) {
+            if (!isAlive) {
+                return null;
+            }
+            wait();
+        }
+        Logger.global.info("1 Task is removed");
+        return (Runnable) taskQueue.removeFirst();
+    }
+
+    public synchronized void close() {
+        if (isAlive) {
+            isAlive = false;
+            taskQueue.clear();
+            interrupt();
+        }
+    }
+
+    public void join() {
+        synchronized (this) {
+            isAlive = false;
+            notifyAll();
+        }
+
+        Thread[] threads = new Thread[activeCount()];
+        int count = enumerate(threads);
+        for (int i = 0; i < count; i++) {
+            try {
+                threads[i].join();
+            } catch (InterruptedException ex) {
+                System.err.println(ex.getMessage());
+            }
+        }
+    }
+
+    private class PooledThread extends Thread {
+
+        public PooledThread() {
+            super(ThreadPool.this, "PooledThread-" + (threadID++));
+        }
+
+        public void run() {
+            while (!isInterrupted()) {
+
+                Runnable task = null;
+                try {
+                    task = getTask();
+                } catch (InterruptedException ex) {
+                    System.err.println(ex.getMessage());
+                }
+
+                if (task == null) {
+                    return;
+                }
+
+                try {
+                    Logger.global.info("Task is run");
+                    task.run();
+                    
+                } catch (Throwable t) {
+                    System.err.println(t.getMessage());
+                }
+            }
+        }
+    }
+}