Code drop from //branches/cupcake/...@124589

43 files changed, 4766 insertions, 16 deletions

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
index 241888a..17391c6 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.Serializable;
 import java.sql.BatchUpdateException;
 import java.util.Arrays;
@@ -26,11 +31,21 @@ 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BatchUpdateException",
+          methodArgs = {}
+        )
+    })
     public void testBatchUpdateException() {
 
         int[] theFinalStates1 = { 0 }; // Error Code state
@@ -75,6 +90,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BatchUpdateException",
+          methodArgs = {int[].class}
+        )
+    })
     public void testBatchUpdateExceptionintArray() {
 
         int[][] init1 = { { 1, 2, 3 }, null };
@@ -121,6 +145,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BatchUpdateException",
+          methodArgs = {String.class, int[].class}
+        )
+    })
     public void testBatchUpdateExceptionStringintArray() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
@@ -176,6 +209,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BatchUpdateException",
+          methodArgs = {String.class, String.class, int[].class}
+        )
+    })
     public void testBatchUpdateExceptionStringStringintArray() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
@@ -233,6 +275,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BatchUpdateException",
+          methodArgs = {String.class, String.class, int.class, int[].class}
+        )
+    })
     public void testBatchUpdateExceptionStringStringintintArray() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
@@ -291,6 +342,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /*
      * Method test for getUpdateCounts
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getUpdateCounts",
+          methodArgs = {}
+        )
+    })
     public void testGetUpdateCounts() {
 
         BatchUpdateException aBatchUpdateException;
@@ -344,6 +404,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationSelf",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
         BatchUpdateException object = new BatchUpdateException();
         SerializationTest.verifySelf(object, BATCHUPDATEEXCEPTION_COMPARATOR);
@@ -352,6 +421,15 @@ public class BatchUpdateExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationGolden",
+          methodArgs = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
         int vendorCode = 10;
         int[] updateCounts = { 1, 2, 3, 4 };
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
index 22409f7..1e5573a 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index 624da41..5eaef52 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.Serializable;
 import java.sql.DataTruncation;
 import org.apache.harmony.testframework.serialization.SerializationTest;
@@ -24,11 +29,21 @@ import org.apache.harmony.testframework.serialization.SerializationTest.Serializ
 
 import junit.framework.TestCase;
 
+@TestTargetClass(DataTruncation.class)
 public class DataTruncationTest extends TestCase {
 
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "DataTruncation",
+          methodArgs = {int.class, boolean.class, boolean.class, int.class, int.class}
+        )
+    })
     public void testDataTruncationintbooleanbooleanintint() {
 
         int[] init1 = { -2147483648, 2147483647, 0, 329751502, 318587557,
@@ -96,6 +111,15 @@ public class DataTruncationTest extends TestCase {
     /*
      * Method test for getIndex
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getIndex",
+          methodArgs = {}
+        )
+    })
     public void testGetIndex() {
 
         DataTruncation aDataTruncation;
@@ -168,6 +192,15 @@ public class DataTruncationTest extends TestCase {
     /*
      * Method test for getParameter
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getParameter",
+          methodArgs = {}
+        )
+    })
     public void testGetParameter() {
 
         DataTruncation aDataTruncation;
@@ -240,6 +273,15 @@ public class DataTruncationTest extends TestCase {
     /*
      * Method test for getRead
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getRead",
+          methodArgs = {}
+        )
+    })
     public void testGetRead() {
 
         DataTruncation aDataTruncation;
@@ -312,6 +354,15 @@ public class DataTruncationTest extends TestCase {
     /*
      * Method test for getDataSize
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDataSize",
+          methodArgs = {}
+        )
+    })
     public void testGetDataSize() {
 
         DataTruncation aDataTruncation;
@@ -384,6 +435,15 @@ public class DataTruncationTest extends TestCase {
     /*
      * Method test for getTransferSize
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getTransferSize",
+          methodArgs = {}
+        )
+    })
     public void testGetTransferSize() {
 
         DataTruncation aDataTruncation;
@@ -456,6 +516,15 @@ public class DataTruncationTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationSelf",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
         DataTruncation object = new DataTruncation(10, true, true, 10, 10);
         SerializationTest.verifySelf(object, DATATRUNCATION_COMPARATOR);
@@ -464,6 +533,15 @@ public class DataTruncationTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationGolden",
+          methodArgs = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
         DataTruncation object = new DataTruncation(10, true, true, 10, 10);
         SerializationTest.verifyGolden(this, object, DATATRUNCATION_COMPARATOR);
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
index c970c70..d6fa92d 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Number> thePublicStatics = new HashMap<String, Number>();
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
index 903b77f..79bfc6c 100644
--- 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
@@ -17,12 +17,17 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
  * 
@@ -124,6 +129,15 @@ public class DateTest extends TestCase {
     /*
      * Test of the Date( long ) constructor
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "Date",
+          methodArgs = {long.class}
+        )
+    })
     public void testDatelong() {
 
         long init1[] = { TIME_TESTDATE1, TIME_TESTDATE2, TIME_TESTDATE3,
@@ -141,6 +155,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) int Date.getHours() method - which always throws
      * an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getHours",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetHours() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -156,6 +179,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) int Date.getMinutes() method - which always
      * throws an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getMinutes",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetMinutes() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -171,6 +203,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) int Date.getSeconds() method - which always
      * throws an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getSeconds",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetSeconds() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -186,6 +227,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) Date.setHours( int ) method - which always
      * throws an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setHours",
+          methodArgs = {int.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testSetHours() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -201,6 +251,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) Date.setMinutes( int ) method - which always
      * throws an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setMinutes",
+          methodArgs = {int.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testSetMinutes() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -217,6 +276,15 @@ public class DateTest extends TestCase {
      * Test of the (deprecated) Date.setSeconds( int ) method - which always
      * throws an IllegalArgumentException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setSeconds",
+          methodArgs = {int.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testSetSeconds() {
         Date theDate = new Date(TIME_TESTDATE1);
@@ -233,6 +301,15 @@ public class DateTest extends TestCase {
      * time zone setting and this test sets the time zone before calling the
      * toString() method.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
     public void testToString() {
         // This test is set up for GMT time zone, so need to set the time zone
         // to GMT first
@@ -250,6 +327,15 @@ public class DateTest extends TestCase {
      * 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.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {long.class}
+        )
+    })
     public void testSetTimelong() {
 
         // Loop over the array of test timezones
@@ -262,6 +348,15 @@ public class DateTest extends TestCase {
     /*
      * Internal method for testing Date.setTime with a specific time zone
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {long.class}
+        )
+    })
     private void testSetTimelong(String timeZoneName, String[] dateArray) {
 
         if (timeZoneName != null) {
@@ -282,6 +377,15 @@ public class DateTest extends TestCase {
      * Test of the Date.valueOf( String ) method This test is not dependent on
      * the default Time Zone setting
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
     public void testValueOf() {
         String SQL_NOTVALID1 = "ABCDEF"; // Invalid date string
         String SQL_NOTVALID2 = "12321.43.56"; // Invalid date string
@@ -310,6 +414,15 @@ public class DateTest extends TestCase {
     /**
      * @tests java.sql.Date#valueOf(String )
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
     public void test_valueOf_IllegalArgumentException() {
         try{
             Date.valueOf("1996-10-07-01");
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
index 73b415b..2f14290 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.ByteArrayOutputStream;
 import java.io.PrintStream;
 import java.io.PrintWriter;
@@ -31,7 +36,7 @@ import java.util.Enumeration;
 import java.util.Properties;
 
 import junit.framework.TestCase;
-
+@TestTargetClass(DriverManager.class)
 /**
  * JUnit Testcase for the java.sql.DriverManager class
  * 
@@ -75,6 +80,15 @@ public class DriverManagerTest extends TestCase {
      * Test for the method DriverManager.deregisterDriver
      * @throws SQLException 
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "deregisterDriver",
+          methodArgs = {Driver.class}
+        )
+    })
     public void testDeregisterDriver() throws SQLException {
         // First get one of the drivers loaded by the test
         Driver aDriver;
@@ -159,6 +173,15 @@ public class DriverManagerTest extends TestCase {
     static String[] invalidConnectionURLs = { invalidConnectionURL2,
             invalidConnectionURL3 };
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {String.class}
+        )
+    })
     public void testGetConnectionString() throws SQLException {
         Connection theConnection = null;
         // validConnection - no user & password required
@@ -180,6 +203,15 @@ public class DriverManagerTest extends TestCase {
     /**
      * @tests java.sql.DriverManager#getConnection(String, Properties)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {String.class, Properties.class}
+        )
+    })
     public void test_getConnection_LStringLProperties() {
         try {
             DriverManager.getConnection("fff", //$NON-NLS-1$
@@ -201,6 +233,15 @@ public class DriverManagerTest extends TestCase {
     /*
      * Class under test for Connection getConnection(String, Properties)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {String.class, Properties.class}
+        )
+    })
     public void testGetConnectionStringProperties() throws SQLException {
         String validURL1 = "jdbc:mikes1:data2";
         String validuser1 = "theuser";
@@ -247,6 +288,15 @@ public class DriverManagerTest extends TestCase {
     /*
      * Class under test for Connection getConnection(String, String, String)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void testGetConnectionStringStringString() throws SQLException {
         String validURL1 = "jdbc:mikes1:data2";
         String validuser1 = "theuser";
@@ -298,6 +348,15 @@ public class DriverManagerTest extends TestCase {
 
     static String exceptionMsg1 = "No suitable driver";
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDriver",
+          methodArgs = {String.class}
+        )
+    })
     public void testGetDriver() throws SQLException {
         for (String element : validURLs) {
             Driver validDriver = DriverManager.getDriver(element);
@@ -316,6 +375,15 @@ public class DriverManagerTest extends TestCase {
 
     } // end method testGetDriver()
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDrivers",
+          methodArgs = {}
+        )
+    })
     public void testGetDrivers() {
         // Load a driver manager
         Enumeration<Driver> driverList = DriverManager.getDrivers();
@@ -333,11 +401,29 @@ public class DriverManagerTest extends TestCase {
 
     static int timeout1 = 25;
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getLoginTimeout",
+          methodArgs = {}
+        )
+    })
     public void testGetLoginTimeout() {
         DriverManager.setLoginTimeout(timeout1);
         assertEquals(timeout1, DriverManager.getLoginTimeout());
     } // end method testGetLoginTimeout()
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getLogStream",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetLogStream() {
         assertNull(DriverManager.getLogStream());
@@ -348,6 +434,15 @@ public class DriverManagerTest extends TestCase {
         DriverManager.setLogStream(null);
     } // end method testGetLogStream()
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getLogWriter",
+          methodArgs = {}
+        )
+    })
     public void testGetLogWriter() {
         assertNull(DriverManager.getLogWriter());
 
@@ -360,6 +455,15 @@ public class DriverManagerTest extends TestCase {
 
     static String testMessage = "DriverManagerTest: test message for print stream";
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "println",
+          methodArgs = {String.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testPrintln() {
         // System.out.println("testPrintln");
@@ -384,6 +488,15 @@ public class DriverManagerTest extends TestCase {
         DriverManager.setLogStream(null);
     } // end method testPrintln()
 
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException/ClassNotFoundException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "registerDriver",
+          methodArgs = {Driver.class}
+        )
+    })
     public void testRegisterDriver() throws ClassNotFoundException,
             SQLException, IllegalAccessException, InstantiationException {
         String EXTRA_DRIVER_NAME = "org.apache.harmony.sql.tests.java.sql.TestHelper_Driver3";
@@ -414,6 +527,15 @@ public class DriverManagerTest extends TestCase {
 
     static int invalidTimeout1 = -10;
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setLoginTimeout",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetLoginTimeout() {
         for (int element : validTimeouts) {
             DriverManager.setLoginTimeout(element);
@@ -429,6 +551,15 @@ public class DriverManagerTest extends TestCase {
 
     static PrintStream testPrintStream = new PrintStream(outputStream2);
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setLogStream",
+          methodArgs = {PrintStream.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testSetLogStream() {
         // System.out.println("testSetLogStream");
@@ -468,6 +599,15 @@ public class DriverManagerTest extends TestCase {
     /**
      * Test for the setLogWriter method
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setLogWriter",
+          methodArgs = {PrintWriter.class}
+        )
+    })
     public void testSetLogWriter() {
         // System.out.println("testSetLogWriter");
         DriverManager.setLogWriter(testPrintWriter);
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
index ec38988..8e93cbe 100644
--- 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
@@ -17,11 +17,16 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.DriverPropertyInfo;
 import java.util.Arrays;
 
 import junit.framework.TestCase;
-
+@TestTargetClass(DriverPropertyInfo.class)
 /**
  * JUnit Testcase for the java.sql.DriverPropertyInfo class
  * 
@@ -32,6 +37,15 @@ public class DriverPropertyInfoTest extends TestCase {
     /*
      * Public statics test
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
     } // end method testPublicStatics
@@ -39,6 +53,15 @@ public class DriverPropertyInfoTest extends TestCase {
     /*
      * Constructor test
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Verification with invalid parameters missed",
+      targets = {
+        @TestTarget(
+          methodName = "DriverPropertyInfo",
+          methodArgs = {String.class, String.class}
+        )
+    })
     public void testDriverPropertyInfoStringString() {
 
         DriverPropertyInfo aDriverPropertyInfo = new DriverPropertyInfo(
@@ -67,6 +90,15 @@ public class DriverPropertyInfoTest extends TestCase {
 
     static String updateName = "updateName";
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicFields() {
 
         // Constructor here...
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
index d3e000d..a455af4 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index 07a25c2..3385ba3 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index 26e61fe..cf13929 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index bb73343..9ce2e99 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.sql.SQLException;
@@ -27,6 +32,7 @@ import org.apache.harmony.testframework.serialization.SerializationTest.Serializ
 import junit.framework.Assert;
 import junit.framework.TestCase;
 
+@TestTargetClass(SQLException.class)
 public class SQLExceptionTest extends TestCase {
 
     static long theFixedSUID = 2135244094396331484L;
@@ -34,6 +40,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * SUID test
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testSUID() {
 
         try {
@@ -52,6 +67,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLException",
+          methodArgs = {String.class, String.class, int.class}
+        )
+    })
     public void testSQLExceptionStringStringint() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", "1", "a",
@@ -104,6 +128,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLException",
+          methodArgs = {String.class, String.class}
+        )
+    })
     public void testSQLExceptionStringString() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
@@ -154,6 +187,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLException",
+          methodArgs = {String.class}
+        )
+    })
     public void testSQLExceptionString() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, 
@@ -203,6 +245,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLException",
+          methodArgs = {}
+        )
+    })
     public void testSQLException() {
 
         String[] theFinalStates1 = { null };
@@ -245,6 +296,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * Method test for getErrorCode
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getErrorCode",
+          methodArgs = {}
+        )
+    })
     public void testGetErrorCode() {
 
         SQLException aSQLException;
@@ -298,6 +358,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * Method test for getNextException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getNextException",
+          methodArgs = {}
+        )
+    })
     public void testGetNextException() {
 
         SQLException aSQLException;
@@ -354,6 +423,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * Method test for getSQLState
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getSQLState",
+          methodArgs = {}
+        )
+    })
     public void testGetSQLState() {
 
         SQLException aSQLException;
@@ -407,6 +485,15 @@ public class SQLExceptionTest extends TestCase {
     /*
      * Method test for setNextException
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setNextException",
+          methodArgs = {SQLException.class}
+        )
+    })
     public void testSetNextExceptionSQLException() {
 
         SQLException[] parm1 = { new SQLException(), null, new SQLException(),
@@ -461,6 +548,15 @@ public class SQLExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationSelf",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
         SQLException object = new SQLException();
         SerializationTest.verifySelf(object, SQLEXCEPTION_COMPARATOR);
@@ -469,6 +565,15 @@ public class SQLExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationGolden",
+          methodArgs = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SQLException nextSQLException = new SQLException("nextReason",
@@ -516,6 +621,15 @@ public class SQLExceptionTest extends TestCase {
     /**
      * @tests java.sql.SQLException#setNextException(java.sql.SQLException)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setNextException",
+          methodArgs = {SQLException.class}
+        )
+    })
     public void test_setNextException_LSQLException() {
         SQLException se1 = new SQLException("reason" , "SQLState" , 1);
         SQLException se2 = new SQLException("reason" , "SQLState" , 2);
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
index 0cf1d45..00f33e8 100644
--- 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
@@ -17,10 +17,15 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.SQLPermission;
 
 import junit.framework.TestCase;
-
+@TestTargetClass(SQLPermission.class)
 /**
  * JUnit Testcase for the java.sql.SQLPermission class
  * 
@@ -35,6 +40,15 @@ public class SQLPermissionTest extends TestCase {
     /*
      * Constructor test
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Null/invalid parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "SQLPermission",
+          methodArgs = {String.class, String.class}
+        )
+    })
     public void testSQLPermissionStringString() {
         String validName = "setLog";
         String validActions = "theActions";
@@ -51,6 +65,15 @@ public class SQLPermissionTest extends TestCase {
     /*
      * Constructor test
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Null parameter checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "SQLPermission",
+          methodArgs = {String.class}
+        )
+    })
     public void testSQLPermissionString() {
         String validName = "setLog";
 
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
index d0998ce..eb35062 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.Serializable;
 import java.sql.SQLException;
 import java.sql.SQLWarning;
@@ -26,11 +31,21 @@ import org.apache.harmony.testframework.serialization.SerializationTest.Serializ
 
 import junit.framework.TestCase;
 
+@TestTargetClass(SQLWarning.class)
 public class SQLWarningTest extends TestCase {
 
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {}
+        )
+    })
     public void testSQLWarning() {
 
         String[] theFinalStates1 = { null };
@@ -73,6 +88,15 @@ public class SQLWarningTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {String.class}
+        )
+    })
     public void testSQLWarningString() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, 
@@ -121,6 +145,15 @@ public class SQLWarningTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {String.class, String.class}
+        )
+    })
     public void testSQLWarningStringString() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", null, "",
@@ -170,6 +203,15 @@ public class SQLWarningTest extends TestCase {
     /*
      * ConstructorTest
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {String.class, String.class, int.class}
+        )
+    })
     public void testSQLWarningStringStringint() {
 
         String[] init1 = { "a", "1", "valid1", "----", "&valid*", "----",
@@ -222,6 +264,15 @@ public class SQLWarningTest extends TestCase {
     /*
      * Method test for getNextWarning
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getNextWarning",
+          methodArgs = {}
+        )
+    })
     public void testGetNextWarning() {
 
         SQLWarning aSQLWarning;
@@ -271,6 +322,19 @@ public class SQLWarningTest extends TestCase {
     /*
      * Method test for setNextWarning
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setNextWarning",
+          methodArgs = {SQLWarning.class}
+        ),
+        @TestTarget(
+          methodName = "getNextWarning",
+          methodArgs = {}
+        )
+    })
     public void testSetNextWarningSQLWarning() {
 
         SQLWarning[] parm1 = { new SQLWarning(), null };
@@ -318,6 +382,19 @@ public class SQLWarningTest extends TestCase {
     /**
      * @tests java.sql.SQLWarning#setNextWarning(java.sql.SQLWarning)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setNextWarning",
+          methodArgs = {SQLWarning.class}
+        ),
+        @TestTarget(
+          methodName = "getNextWarning",
+          methodArgs = {}
+        )
+    })
     public void test_setNextWarning_SQLWarning() {
         SQLWarning sw = new SQLWarning("reason", "SQLState", 0);
         SQLWarning sw1 = new SQLWarning("reason", "SQLState", 1);
@@ -352,6 +429,15 @@ public class SQLWarningTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
         SQLWarning object = new SQLWarning();
         SerializationTest.verifySelf(object, SQLWARNING_COMPARATOR);
@@ -360,6 +446,15 @@ public class SQLWarningTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "SQLWarning",
+          methodArgs = {String.class, String.class, int.class}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
         SQLWarning object = new SQLWarning();
         
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
index d0febeb..5aca5e3 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index 299c33a..f82271e 100644
--- 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
@@ -17,12 +17,15 @@
 
 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 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
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
index a523b39..92011ee 100644
--- 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
@@ -17,11 +17,17 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Time;
 import java.util.TimeZone;
 
 import junit.framework.TestCase;
 
+@TestTargetClass(Time.class)
 /**
  * JUnit Testcase for the java.sql.Time class
  * 
@@ -73,6 +79,15 @@ public class TimeTest extends TestCase {
             STRING_JP_ARRAY };
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Deprecated method",
+      targets = {
+        @TestTarget(
+          methodName = "Time",
+          methodArgs = {int.class, int.class, int.class}
+        )
+    })
     public void testTimeintintint() {
         Time theTime = new Time(10, 45, 20);
 
@@ -80,6 +95,15 @@ public class TimeTest extends TestCase {
         assertNotNull(theTime);
     } // end method testTimeintintint()
 
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Incorrect parameter checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "Time",
+          methodArgs = {long.class}
+        )
+    })
     public void testTime() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -87,6 +111,15 @@ public class TimeTest extends TestCase {
         assertNotNull(theTime);
     } // end method testTime()
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
     public void testToString() {
         // Loop through the timezones testing the String conversion for each
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -95,6 +128,15 @@ public class TimeTest extends TestCase {
 
     } // end method test
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
     private void testToString(String timeZone, long[] theTimes,
             String[] theTimeStrings) {
         // Set the timezone
@@ -113,6 +155,15 @@ public class TimeTest extends TestCase {
     /*
      * Method test for valueOf
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
     public void testValueOfString() {
         TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
 
@@ -138,6 +189,15 @@ public class TimeTest extends TestCase {
 
     } // end method testValueOfString
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {long.class}
+        )
+    })
     public void testSetTime() {
         // Ensure that the timezone is set to GMT
         TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
@@ -149,6 +209,15 @@ public class TimeTest extends TestCase {
         assertEquals(STRING_TEST2, theTime.toString());
     } // end method testSetTime()
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setDate",
+          methodArgs = {int.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testSetDate() {
         Time theTime = new Time(TIME_TEST1);
@@ -162,6 +231,15 @@ public class TimeTest extends TestCase {
     } // end method testSetDate()
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setMonth",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetMonth() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -174,6 +252,15 @@ public class TimeTest extends TestCase {
     } // end method testSetMonth()
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setYear",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetYear() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -186,6 +273,15 @@ public class TimeTest extends TestCase {
     } // end method testSetYear()
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDate",
+          methodArgs = {}
+        )
+    })
     public void testGetDate() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -198,6 +294,15 @@ public class TimeTest extends TestCase {
     } // end method test
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDay",
+          methodArgs = {}
+        )
+    })
     public void testGetDay() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -210,6 +315,15 @@ public class TimeTest extends TestCase {
     } // end method test
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getMonth",
+          methodArgs = {}
+        )
+    })
     public void testGetMonth() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -222,6 +336,15 @@ public class TimeTest extends TestCase {
     } // end method test
 
     @SuppressWarnings("deprecation")
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getYear",
+          methodArgs = {}
+        )
+    })
     public void testGetYear() {
         Time theTime = new Time(TIME_TEST1);
 
@@ -236,6 +359,15 @@ public class TimeTest extends TestCase {
     /**
      * @tests java.sql.Time#valueOf(String )
      */
+     @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
      public void test_valueOf_IllegalArgumentException() {
             try{
                 Time.valueOf("15:43:12:34");
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
index 7c5d7ab..8504078 100644
--- 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
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Timestamp;
 import java.util.Date;
 import java.util.TimeZone;
@@ -24,6 +29,7 @@ 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
  * 
@@ -109,6 +115,15 @@ public class TimestampTest extends TestCase {
     /*
      * Constructor test
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Incorrect parameter checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "Timestamp",
+          methodArgs = {long.class}
+        )
+    })
     public void testTimestamplong() {
         Timestamp theTimestamp = new Timestamp(TIME_TEST1);
 
@@ -119,6 +134,15 @@ public class TimestampTest extends TestCase {
     /*
      * Constructor test
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "Timestamp",
+          methodArgs = {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
@@ -171,6 +195,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for setTime
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {long.class}
+        )
+    })
     public void testSetTimelong() {
         // First set the timezone to GMT
         TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
@@ -189,6 +222,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getTime
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getTime",
+          methodArgs = {}
+        )
+    })
     public void testGetTime() {
         // First set the timezone to GMT
         TimeZone.setDefault(TimeZone.getTimeZone("GMT"));
@@ -203,6 +245,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getYear
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getYear",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetYear() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -215,6 +266,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getMonth
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getMonth",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetMonth() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -227,6 +287,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getDate
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getDate",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetDate() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -239,6 +308,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getHours
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getHours",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetHours() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -251,6 +329,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getMinutes
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getMinutes",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetMinutes() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -263,6 +350,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getSeconds
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Deprecation",
+      targets = {
+        @TestTarget(
+          methodName = "getSeconds",
+          methodArgs = {}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testGetSeconds() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -277,6 +373,15 @@ public class TimestampTest extends TestCase {
      */
     static String theExceptionMessage = "Timestamp format must be yyyy-mm-dd hh:mm:ss.fffffffff";
 
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
     public void testValueOfString() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
             Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
@@ -308,6 +413,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for valueOf
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "valueOf",
+          methodArgs = {String.class}
+        )
+    })
     public void testValueOfString1() {
 
         Timestamp theReturn;
@@ -353,6 +467,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for toString
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
     public void testToString() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
             Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
@@ -364,6 +487,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for getNanos
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getNanos",
+          methodArgs = {}
+        )
+    })
     public void testGetNanos() {
         for (int i = 0; i < TIME_ARRAY.length; i++) {
             Timestamp theTimestamp = new Timestamp(TIME_ARRAY[i]);
@@ -375,6 +507,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for setNanos
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setNanos",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetNanosint() {
         int[] NANOS_INVALID = { -137891990, 1635665198, -1 };
         for (int i = 0; i < TIME_ARRAY.length; i++) {
@@ -407,6 +548,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for equals
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "equals",
+          methodArgs = {Timestamp.class}
+        )
+    })
     public void testEqualsTimestamp() {
         for (long element : TIME_ARRAY) {
             Timestamp theTimestamp = new Timestamp(element);
@@ -429,6 +579,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for equals
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "equals",
+          methodArgs = {Object.class}
+        )
+    })
     public void testEqualsObject() {
         for (long element : TIME_ARRAY) {
             Timestamp theTimestamp = new Timestamp(element);
@@ -457,6 +616,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for before
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "before",
+          methodArgs = {Timestamp.class}
+        )
+    })
     public void testBeforeTimestamp() {
         Timestamp theTest = new Timestamp(TIME_LATE);
 
@@ -488,6 +656,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for after
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "after",
+          methodArgs = {Timestamp.class}
+        )
+    })
     public void testAfterTimestamp() {
         Timestamp theTest = new Timestamp(TIME_LATE);
 
@@ -519,6 +696,15 @@ public class TimestampTest extends TestCase {
     /*
      * Method test for compareTo
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "compareTo",
+          methodArgs = {Timestamp.class}
+        )
+    })
     @SuppressWarnings("deprecation")
     public void testCompareToTimestamp() {
         Timestamp theTest = new Timestamp(TIME_EARLY);
@@ -556,6 +742,15 @@ public class TimestampTest extends TestCase {
     /**
      * @tests java.sql.Timestamp#compareTo(java.util.Date)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "compareTo",
+          methodArgs = {Date.class}
+        )
+    })
     public void testCompareToDate() {
         Date theTest = new Timestamp(TIME_EARLY);
         Date theTest2 = new Timestamp(TIME_LATE);
@@ -590,6 +785,15 @@ public class TimestampTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationSelf",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
         Timestamp object = new Timestamp(100L);
         SerializationTest.verifySelf(object);
@@ -598,6 +802,15 @@ public class TimestampTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Serialization test",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationGolden",
+          methodArgs = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
         Timestamp object = new Timestamp(100L);
         SerializationTest.verifyGolden(this, object);
@@ -606,6 +819,15 @@ public class TimestampTest extends TestCase {
     /**
      * @tests java.sql.Timestamp#toString()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
     public void test_toString() {
 
         Timestamp t1 = new Timestamp(Long.MIN_VALUE);
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
index 5ee8860..49b583a 100644
--- 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
@@ -17,17 +17,32 @@
 
 package org.apache.harmony.sql.tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Field testing",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
     public void testPublicStatics() {
 
         HashMap<String, Integer> thePublicStatics = new HashMap<String, Integer>();
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
index a5d7617..34d895c 100644
--- 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
@@ -17,12 +17,31 @@
 
 package org.apache.harmony.sql.tests.javax.sql;
 
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetClass;
+
 import java.sql.SQLException;
 import javax.sql.ConnectionEvent;
+import javax.sql.PooledConnection;
+import javax.sql.RowSet;
+
 import junit.framework.TestCase;
 
+@TestTargetClass(ConnectionEvent.class)
 public class ConnectionEventTest extends TestCase {
 
+    /**
+     * @tests {@link javax.sql.RowSetEvent#RowSetEvent(javax.sql.RowSet)}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies RowSetEvent() constructor.",
+            targets = { @TestTarget(methodName = "RowSetEvent", 
+                                    methodArgs = {RowSet.class})                         
+            }
+    )    
     public void testConstructorConnection() {
         try {
             new ConnectionEvent(null);
@@ -36,6 +55,16 @@ public class ConnectionEventTest extends TestCase {
         assertNull(ce.getSQLException());
     }
     
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#ConnectionEvent(PooledConnection, SQLException)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies ConnectionEvent() constructor for the abnormal case that an error has occurred on the pooled connection.",
+            targets = { @TestTarget(methodName = "testConnectionEventPooledConnection", 
+                                    methodArgs = {PooledConnection.class,SQLException.class})                         
+            }
+    )  
     public void testConstructorConnectionSQLException() {
         try {
             new ConnectionEvent(null, null);
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
index e78280b..0ec9084 100644
--- 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
@@ -17,11 +17,28 @@
 
 package org.apache.harmony.sql.tests.javax.sql;
 
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetClass;
+
+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)}.
+     */
+    @TestInfo(
+            level = TestLevel.PARTIAL,
+            purpose = "Verifies RowSetEvent() constructor.",
+            targets = { @TestTarget(methodName = "RowSetEvent", 
+                                    methodArgs = {RowSet.class})                         
+            }
+    )    
     public void testConstructor() {
         try {
             new RowSetEvent(null);
diff --git a/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java b/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java
index 42ae249..bd72e4e 100755
--- a/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java
+++ b/sql/src/test/java/tests/java/sql/DatabaseMetaDataTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.ResultSet;
@@ -24,7 +29,6 @@ import java.sql.SQLException;
 import java.sql.Statement;
 import java.sql.Types;
 import java.util.Arrays;
-import java.util.HashSet;
 
 import tests.support.DatabaseCreator;
 import tests.support.Support_SQL;
@@ -34,6 +38,7 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+@TestTargetClass(DatabaseMetaData.class)
 public class DatabaseMetaDataTest extends TestCase {
     private static String VIEW_NAME = "myView";
 
@@ -116,6 +121,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#allProceduresAreCallable()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "allProceduresAreCallable",
+          methodArgs = {}
+        )
+    })
     public void test_allProceduresAreCallable() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -168,6 +182,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#dataDefinitionCausesTransactionCommit()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "dataDefinitionCausesTransactionCommit",
+          methodArgs = {}
+        )
+    })
     public void test_dataDefinitionCausesTransactionCommit()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -176,6 +199,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#dataDefinitionIgnoredInTransactions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "dataDefinitionIgnoredInTransactions",
+          methodArgs = {}
+        )
+    })
     public void test_dataDefinitionIgnoredInTransactions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -183,6 +215,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#deletesAreDetected(int)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "deletesAreDetected",
+          methodArgs = {int.class}
+        )
+    })
     public void test_deletesAreDetectedI() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -190,6 +231,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#doesMaxRowSizeIncludeBlobs()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "doesMaxRowSizeIncludeBlobs",
+          methodArgs = {}
+        )
+    })
     public void test_doesMaxRowSizeIncludeBlobs() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -198,6 +248,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getAttributes(java.lang.String,
      *        java.lang.String, java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getAttributes",
+          methodArgs = {String.class, String.class, String.class, String.class}
+        )
+    })
     public void test_getAttributesLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -207,6 +266,16 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getBestRowIdentifier(java.lang.String,
      *        java.lang.String, java.lang.String, int, boolean)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "All variants of parameters were not tested. " +
+                  "SQLException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getBestRowIdentifier",
+          methodArgs = {String.class, String.class, String.class, int.class, boolean.class}
+        )
+    })
     public void test_getBestRowIdentifierLjava_lang_StringLjava_lang_StringLjava_lang_StringIZ()
             throws SQLException {
         ResultSet result = statementForward.executeQuery("SELECT * FROM "
@@ -250,6 +319,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getCatalogSeparator()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getCatalogSeparator",
+          methodArgs = {}
+        )
+    })
     public void test_getCatalogSeparator() throws SQLException {
         assertTrue("Incorrect catalog separator", "".equals(meta
                 .getCatalogSeparator().trim()));
@@ -258,6 +336,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getCatalogTerm()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getCatalogTerm",
+          methodArgs = {}
+        )
+    })
     public void test_getCatalogTerm() throws SQLException {
         assertTrue("Incorrect catalog term", "".equals(meta
                 .getCatalogSeparator().trim()));
@@ -266,6 +353,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getCatalogs()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Received result wasn't checked.",
+      targets = {
+        @TestTarget(
+          methodName = "getCatalogs",
+          methodArgs = {}
+        )
+    })
     public void test_getCatalogs() throws SQLException {
         ResultSet rs = meta.getCatalogs();
         // TODO getCatalog is not supported
@@ -334,6 +431,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getConnection()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {}
+        )
+    })
     public void test_getConnection() throws SQLException {
         assertEquals("Incorrect connection value", conn, meta.getConnection());
     }
@@ -343,6 +449,16 @@ public class DatabaseMetaDataTest extends TestCase {
      *        java.lang.String, java.lang.String, java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "All variants of parameters were not tested.",
+      targets = {
+        @TestTarget(
+          methodName = "getCrossReference",
+          methodArgs = {String.class, String.class, String.class, String.class, String.class, String.class}
+        )
+    })
     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,
@@ -398,6 +514,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDatabaseMajorVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDatabaseMajorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDatabaseMajorVersion() throws SQLException {
         assertTrue("Incorrdct database major version", meta
                 .getDatabaseMajorVersion() >= 0);
@@ -406,6 +531,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDatabaseMinorVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDatabaseMinorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDatabaseMinorVersion() throws SQLException {
         assertTrue("Incorrect database minor version", meta
                 .getDatabaseMinorVersion() >= 0);
@@ -414,6 +548,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDatabaseProductName()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDatabaseProductName",
+          methodArgs = {}
+        )
+    })
     public void test_getDatabaseProductName() throws SQLException {
         assertTrue("Incorrect database product name", !"".equals(meta
                 .getDatabaseProductName().trim()));
@@ -422,6 +565,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDatabaseProductVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDatabaseProductVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDatabaseProductVersion() throws SQLException {
         assertTrue("Incorrect database product version", !"".equals(meta
                 .getDatabaseProductVersion().trim()));
@@ -430,6 +582,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDefaultTransactionIsolation()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDefaultTransactionIsolation",
+          methodArgs = {}
+        )
+    })
     public void test_getDefaultTransactionIsolation() throws SQLException {
         int defaultLevel = meta.getDefaultTransactionIsolation();
         switch (defaultLevel) {
@@ -448,6 +609,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDriverMajorVersion()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDriverMajorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDriverMajorVersion() {
         assertTrue("Incorrect driver major version", meta
                 .getDriverMajorVersion() >= 0);
@@ -456,6 +626,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDriverMinorVersion()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getDriverMinorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDriverMinorVersion() {
         assertTrue("Incorrect driver minor version", meta
                 .getDriverMinorVersion() >= 0);
@@ -464,6 +643,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDriverName()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDriverName",
+          methodArgs = {}
+        )
+    })
     public void test_getDriverName() throws SQLException {
         assertTrue("Incorrect driver name", !"".equals(meta.getDriverName()
                 .trim()));
@@ -472,6 +660,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getDriverVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getDriverVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getDriverVersion() throws SQLException {
         assertTrue("Incorrect driver version", !"".equals(meta
                 .getDriverVersion().trim()));
@@ -537,6 +734,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getExtraNameCharacters()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getExtraNameCharacters",
+          methodArgs = {}
+        )
+    })
     public void test_getExtraNameCharacters() throws SQLException {
         assertNotNull("Incorrect extra name characters", meta
                 .getExtraNameCharacters());
@@ -545,6 +751,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getIdentifierQuoteString()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getIdentifierQuoteString",
+          methodArgs = {}
+        )
+    })
     public void test_getIdentifierQuoteString() throws SQLException {
         assertTrue("Incorrect identifier of quoted string", !"".equals(meta
                 .getIdentifierQuoteString().trim()));
@@ -554,6 +769,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getImportedKeys(java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getImportedKeys",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void test_getImportedKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         ResultSet rs = meta.getImportedKeys(conn.getCatalog(), null,
@@ -658,6 +882,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getJDBCMajorVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getJDBCMajorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getJDBCMajorVersion() throws SQLException {
         assertTrue("Incorrect JDBC major version",
                 meta.getJDBCMajorVersion() >= 0);
@@ -666,6 +899,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getJDBCMinorVersion()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getJDBCMinorVersion",
+          methodArgs = {}
+        )
+    })
     public void test_getJDBCMinorVersion() throws SQLException {
         assertTrue("Incorrect JDBC minor version",
                 meta.getJDBCMinorVersion() >= 0);
@@ -674,6 +916,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxBinaryLiteralLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxBinaryLiteralLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxBinaryLiteralLength() throws SQLException {
         assertTrue("Incorrect binary literal length", meta
                 .getMaxBinaryLiteralLength() >= 0);
@@ -682,6 +933,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxCatalogNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxCatalogNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxCatalogNameLength() throws SQLException {
         assertTrue("Incorrect name length", meta.getMaxCatalogNameLength() >= 0);
     }
@@ -689,6 +949,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxCharLiteralLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxCharLiteralLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxCharLiteralLength() throws SQLException {
         assertTrue("Incorrect char literal length", meta
                 .getMaxCharLiteralLength() >= 0);
@@ -697,6 +966,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnNameLength() throws SQLException {
         assertTrue("Incorrect column name length", meta
                 .getMaxColumnNameLength() >= 0);
@@ -705,6 +983,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnsInGroupBy()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnsInGroupBy",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnsInGroupBy() throws SQLException {
         assertTrue("Incorrect number of columns",
                 meta.getMaxColumnsInGroupBy() >= 0);
@@ -713,6 +1000,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnsInIndex()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnsInIndex",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnsInIndex() throws SQLException {
         assertTrue("Incorrect number of columns",
                 meta.getMaxColumnsInIndex() >= 0);
@@ -721,6 +1017,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnsInOrderBy()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnsInOrderBy",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnsInOrderBy() throws SQLException {
         assertTrue("Incorrect number of columns",
                 meta.getMaxColumnsInOrderBy() >= 0);
@@ -729,6 +1034,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnsInSelect()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnsInSelect",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnsInSelect() throws SQLException {
         assertTrue("Incorrect number of columns",
                 meta.getMaxColumnsInSelect() >= 0);
@@ -737,6 +1051,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxColumnsInTable()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxColumnsInTable",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxColumnsInTable() throws SQLException {
         assertTrue("Incorrect number of columns",
                 meta.getMaxColumnsInTable() >= 0);
@@ -745,6 +1068,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxConnections()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxConnections",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxConnections() throws SQLException {
         assertTrue("Incorrect number of connections",
                 meta.getMaxConnections() >= 0);
@@ -753,6 +1085,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxCursorNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxCursorNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxCursorNameLength() throws SQLException {
         int nameLength = meta.getMaxCursorNameLength();
         if (nameLength > 0) {
@@ -770,6 +1111,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxIndexLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxIndexLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxIndexLength() throws SQLException {
         assertTrue("Incorrect length of index", meta.getMaxIndexLength() >= 0);
     }
@@ -777,6 +1127,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxProcedureNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxProcedureNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxProcedureNameLength() throws SQLException {
         assertTrue("Incorrect length of procedure name", meta
                 .getMaxProcedureNameLength() >= 0);
@@ -785,6 +1144,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxRowSize()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxRowSize",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxRowSize() throws SQLException {
         assertTrue("Incorrect size of row", meta.getMaxRowSize() >= 0);
     }
@@ -792,6 +1160,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxSchemaNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxSchemaNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxSchemaNameLength() throws SQLException {
         assertTrue("Incorrect length of schema name", meta
                 .getMaxSchemaNameLength() >= 0);
@@ -800,6 +1177,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxStatementLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxStatementLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxStatementLength() throws SQLException {
         assertTrue("Incorrect length of statement", meta
                 .getMaxStatementLength() >= 0);
@@ -808,6 +1194,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxStatements()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxStatements",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxStatements() throws SQLException {
         assertTrue("Incorrect number of statements",
                 meta.getMaxStatements() >= 0);
@@ -816,6 +1211,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxTableNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxTableNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxTableNameLength() throws SQLException {
         assertTrue("Incorrect length of table name", meta
                 .getMaxTableNameLength() >= 0);
@@ -824,6 +1228,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxTablesInSelect()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxTablesInSelect",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxTablesInSelect() throws SQLException {
         assertTrue("Incorrect number of tables",
                 meta.getMaxTablesInSelect() >= 0);
@@ -832,6 +1245,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getMaxUserNameLength()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMaxUserNameLength",
+          methodArgs = {}
+        )
+    })
     public void test_getMaxUserNameLength() throws SQLException {
         assertTrue("Incorrect length of user name",
                 meta.getMaxUserNameLength() >= 0);
@@ -840,6 +1262,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getNumericFunctions()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getNumericFunctions",
+          methodArgs = {}
+        )
+    })
     public void test_getNumericFunctions() throws SQLException {
         assertTrue("Incorrect list of math functions", "".equals(meta
                 .getNumericFunctions().trim()));
@@ -849,6 +1280,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getPrimaryKeys(java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getPrimaryKeys",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void test_getPrimaryKeysLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         ResultSet rs = meta.getPrimaryKeys(conn.getCatalog(), null,
@@ -881,6 +1321,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getProcedureColumns(java.lang.String,
      *        java.lang.String, java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getProcedureColumns",
+          methodArgs = {String.class, String.class, String.class, String.class}
+        )
+    })
     public void test_getProcedureColumnsLjava_lang_StringLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -889,6 +1338,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getProcedureTerm()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getProcedureTerm",
+          methodArgs = {}
+        )
+    })
     public void test_getProcedureTerm() throws SQLException {
         assertTrue("Incorrect procedure term", "".equals(meta
                 .getProcedureTerm().trim()));
@@ -898,6 +1356,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getProcedures(java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getProcedures",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void test_getProceduresLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -906,6 +1373,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getResultSetHoldability()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getResultSetHoldability",
+          methodArgs = {}
+        )
+    })
     public void test_getResultSetHoldability() throws SQLException {
         int hdb = meta.getResultSetHoldability();
         switch (hdb) {
@@ -923,6 +1399,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSQLKeywords()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSQLKeywords",
+          methodArgs = {}
+        )
+    })
     public void test_getSQLKeywords() throws SQLException {
         assertTrue("Incorrect SQL keywords", !"".equals(meta.getSQLKeywords()
                 .trim()));
@@ -931,6 +1416,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSQLStateType()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSQLStateType",
+          methodArgs = {}
+        )
+    })
     public void test_getSQLStateType() throws SQLException {
         int type = meta.getSQLStateType();
         switch (type) {
@@ -946,6 +1440,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSchemaTerm()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSchemaTerm",
+          methodArgs = {}
+        )
+    })
     public void test_getSchemaTerm() throws SQLException {
         assertNotNull("Incorrect schema term", meta.getSchemaTerm());
     }
@@ -953,6 +1456,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSchemas()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSchemas",
+          methodArgs = {}
+        )
+    })
     public void test_getSchemas() throws SQLException {
         ResultSet rs = meta.getSchemas();
         ResultSetMetaData rsmd = rs.getMetaData();
@@ -970,6 +1482,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSearchStringEscape()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSearchStringEscape",
+          methodArgs = {}
+        )
+    })
     public void test_getSearchStringEscape() throws SQLException {
         assertTrue("Incorrect search string escape", !"".equals(meta
                 .getSearchStringEscape().trim()));
@@ -978,6 +1499,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getStringFunctions()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getStringFunctions",
+          methodArgs = {}
+        )
+    })
     public void test_getStringFunctions() throws SQLException {
         assertTrue("Incorrect string functions", "".equals(meta
                 .getStringFunctions().trim()));
@@ -987,6 +1517,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getSuperTables(java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getSuperTables",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void test_getSuperTablesLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -996,6 +1535,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getSuperTypes(java.lang.String,
      *        java.lang.String, java.lang.String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getSuperTypes",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void test_getSuperTypesLjava_lang_StringLjava_lang_StringLjava_lang_String()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1004,6 +1552,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getSystemFunctions()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getSystemFunctions",
+          methodArgs = {}
+        )
+    })
     public void test_getSystemFunctions() throws SQLException {
         assertTrue("No system function exist", meta.getSystemFunctions()
                 .trim().equals(""));
@@ -1113,6 +1670,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getTableTypes()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTableTypes",
+          methodArgs = {}
+        )
+    })
     public void test_getTableTypes() throws SQLException {
         String[] tableTypes = { "LOCAL TEMPORARY", "TABLE", "VIEW" };
         ResultSet rs = meta.getTableTypes();
@@ -1128,6 +1694,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getTables(java.lang.String,
      *        java.lang.String, java.lang.String, java.lang.String[])
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTables",
+          methodArgs = {String.class, String.class, String.class, String[].class}
+        )
+    })
     public void test_getTablesLjava_lang_StringLjava_lang_StringLjava_lang_String$Ljava_lang_String()
             throws SQLException {
         String[] tablesName = { VIEW_NAME, DatabaseCreator.TEST_TABLE1,
@@ -1187,6 +1762,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getTimeDateFunctions()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTimeDateFunctions",
+          methodArgs = {}
+        )
+    })
     public void test_getTimeDateFunctions() throws SQLException {
         assertFalse("No time and data functions exist", !meta
                 .getTimeDateFunctions().trim().equals(""));
@@ -1195,6 +1779,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getTypeInfo()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTypeInfo",
+          methodArgs = {}
+        )
+    })
     public void test_getTypeInfo() throws SQLException {
         insertNewRecord();
 
@@ -1234,6 +1827,15 @@ public class DatabaseMetaDataTest extends TestCase {
      * @tests java.sql.DatabaseMetaData #getUDTs(java.lang.String,
      *        java.lang.String, java.lang.String, int[])
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "getUDTs",
+          methodArgs = {String.class, String.class, String.class, int[].class}
+        )
+    })
     public void test_getUDTsLjava_lang_StringLjava_lang_StringLjava_lang_String$I()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1242,6 +1844,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#getURL()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getURL",
+          methodArgs = {}
+        )
+    })
     public void test_getURL() throws SQLException {
         assertEquals("Wrong url", Support_SQL.sqlUrl, meta.getURL());
     }
@@ -1286,6 +1897,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#insertsAreDetected(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "insertsAreDetected",
+          methodArgs = {int.class}
+        )
+    })
     public void test_insertsAreDetectedI() throws SQLException {
         assertFalse(
                 "visible row insert can be detected for TYPE_FORWARD_ONLY type",
@@ -1301,6 +1922,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#isCatalogAtStart()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "isCatalogAtStart",
+          methodArgs = {}
+        )
+    })
     public void test_isCatalogAtStart() throws SQLException {
         assertFalse(
                 "catalog doesn't appear at the start of a fully qualified table name",
@@ -1310,6 +1940,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#isReadOnly()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "isReadOnly",
+          methodArgs = {}
+        )
+    })
     public void test_isReadOnly() throws SQLException {
         assertFalse("database is not read-only", meta.isReadOnly());
     }
@@ -1317,6 +1956,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#locatorsUpdateCopy()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "locatorsUpdateCopy",
+          methodArgs = {}
+        )
+    })
     public void test_locatorsUpdateCopy() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1324,6 +1972,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#nullPlusNonNullIsNull()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "nullPlusNonNullIsNull",
+          methodArgs = {}
+        )
+    })
     public void test_nullPlusNonNullIsNull() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1331,6 +1988,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#nullsAreSortedAtEnd()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "nullsAreSortedAtEnd",
+          methodArgs = {}
+        )
+    })
     public void test_nullsAreSortedAtEnd() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1338,6 +2004,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#nullsAreSortedAtStart()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "nullsAreSortedAtStart",
+          methodArgs = {}
+        )
+    })
     public void test_nullsAreSortedAtStart() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1345,6 +2020,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#nullsAreSortedHigh()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "nullsAreSortedHigh",
+          methodArgs = {}
+        )
+    })
     public void test_nullsAreSortedHigh() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1352,6 +2036,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#nullsAreSortedLow()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "nullsAreSortedLow",
+          methodArgs = {}
+        )
+    })
     public void test_nullsAreSortedLow() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1359,6 +2052,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#othersDeletesAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "othersDeletesAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_othersDeletesAreVisibleI() throws SQLException {
         assertFalse(
                 "deletes made by others are visible for TYPE_FORWARD_ONLY type",
@@ -1376,6 +2079,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#othersInsertsAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "othersInsertsAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_othersInsertsAreVisibleI() throws SQLException {
         assertFalse(
                 "inserts made by others are visible for TYPE_FORWARD_ONLY type",
@@ -1393,6 +2106,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#othersUpdatesAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "othersUpdatesAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_othersUpdatesAreVisibleI() throws SQLException {
         assertFalse(
                 "updates made by others are visible for TYPE_FORWARD_ONLY type",
@@ -1410,6 +2133,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#ownDeletesAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "ownDeletesAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_ownDeletesAreVisibleI() throws SQLException {
         // TODO not supported
 //        assertFalse(
@@ -1428,6 +2161,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#ownInsertsAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "ownInsertsAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_ownInsertsAreVisibleI() throws SQLException {
 //        assertFalse(
 //                "result set's own inserts are visible for TYPE_FORWARD_ONLY type",
@@ -1445,6 +2188,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#ownUpdatesAreVisible(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "ownUpdatesAreVisible",
+          methodArgs = {int.class}
+        )
+    })
     public void test_ownUpdatesAreVisibleI() throws SQLException {
         // TODO not supported
 //        assertFalse(
@@ -1463,6 +2216,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesLowerCaseIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "storesLowerCaseIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesLowerCaseIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1470,6 +2232,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesLowerCaseQuotedIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "storesLowerCaseQuotedIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesLowerCaseQuotedIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1477,6 +2248,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesMixedCaseIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Method storesMixedCaseQuotedIdentifiers was invoked instead of storesMixedCaseIdentifiers",
+      targets = {
+        @TestTarget(
+          methodName = "storesMixedCaseIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesMixedCaseIdentifiers() throws SQLException {
         insertNewRecord();
 
@@ -1498,6 +2278,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesMixedCaseQuotedIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "storesMixedCaseQuotedIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesMixedCaseQuotedIdentifiers() throws SQLException {
         String quote = meta.getIdentifierQuoteString();
 
@@ -1521,6 +2310,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesUpperCaseIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "storesUpperCaseIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesUpperCaseIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1528,6 +2326,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#storesUpperCaseQuotedIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "storesUpperCaseQuotedIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_storesUpperCaseQuotedIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1535,6 +2342,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsANSI92EntryLevelSQL()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsANSI92EntryLevelSQL",
+          methodArgs = {}
+        )
+    })
     public void test_supportsANSI92EntryLevelSQL() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1542,6 +2358,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsANSI92FullSQL()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsANSI92FullSQL",
+          methodArgs = {}
+        )
+    })
     public void test_supportsANSI92FullSQL() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1549,6 +2374,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsANSI92IntermediateSQL()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsANSI92IntermediateSQL",
+          methodArgs = {}
+        )
+    })
     public void test_supportsANSI92IntermediateSQL() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1556,6 +2390,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsAlterTableWithAddColumn()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsAlterTableWithAddColumn",
+          methodArgs = {}
+        )
+    })
     public void test_supportsAlterTableWithAddColumn() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1563,6 +2406,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsAlterTableWithDropColumn()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsAlterTableWithDropColumn",
+          methodArgs = {}
+        )
+    })
     public void test_supportsAlterTableWithDropColumn() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1570,6 +2422,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsBatchUpdates()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsBatchUpdates",
+          methodArgs = {}
+        )
+    })
     public void test_supportsBatchUpdates() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1577,6 +2438,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCatalogsInDataManipulation()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCatalogsInDataManipulation",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCatalogsInDataManipulation() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1584,6 +2454,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCatalogsInIndexDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCatalogsInIndexDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCatalogsInIndexDefinitions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1591,6 +2470,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCatalogsInPrivilegeDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCatalogsInPrivilegeDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCatalogsInPrivilegeDefinitions()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1599,6 +2487,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCatalogsInProcedureCalls()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCatalogsInProcedureCalls",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCatalogsInProcedureCalls() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1606,6 +2503,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCatalogsInTableDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCatalogsInTableDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCatalogsInTableDefinitions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1613,6 +2519,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsColumnAliasing()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsColumnAliasing",
+          methodArgs = {}
+        )
+    })
     public void test_supportsColumnAliasing() throws SQLException {
         insertNewRecord();
 
@@ -1637,6 +2552,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsConvert()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsConvert",
+          methodArgs = {}
+        )
+    })
     public void test_supportsConvert() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1644,6 +2568,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsConvert(int, int)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsConvert",
+          methodArgs = {int.class, int.class}
+        )
+    })
     public void test_supportsConvertII() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1651,6 +2584,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCoreSQLGrammar()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCoreSQLGrammar",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCoreSQLGrammar() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1658,6 +2600,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsCorrelatedSubqueries()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsCorrelatedSubqueries",
+          methodArgs = {}
+        )
+    })
     public void test_supportsCorrelatedSubqueries() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1665,6 +2616,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsDataDefinitionAndDataManipulationTransactions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsDataDefinitionAndDataManipulationTransactions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsDataDefinitionAndDataManipulationTransactions()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1673,6 +2633,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsDataManipulationTransactionsOnly()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsDataManipulationTransactionsOnly",
+          methodArgs = {}
+        )
+    })
     public void test_supportsDataManipulationTransactionsOnly()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1681,6 +2650,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsDifferentTableCorrelationNames()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsDifferentTableCorrelationNames",
+          methodArgs = {}
+        )
+    })
     public void test_supportsDifferentTableCorrelationNames()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1689,6 +2667,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsExpressionsInOrderBy()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsExpressionsInOrderBy",
+          methodArgs = {}
+        )
+    })
     public void test_supportsExpressionsInOrderBy() throws SQLException {
         insertNewRecord();
 
@@ -1710,6 +2697,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsExtendedSQLGrammar()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsExtendedSQLGrammar",
+          methodArgs = {}
+        )
+    })
     public void test_supportsExtendedSQLGrammar() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1717,6 +2713,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsFullOuterJoins()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsFullOuterJoins",
+          methodArgs = {}
+        )
+    })
     public void test_supportsFullOuterJoins() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1724,6 +2729,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsGetGeneratedKeys()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsGetGeneratedKeys",
+          methodArgs = {}
+        )
+    })
     public void test_supportsGetGeneratedKeys() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1731,6 +2745,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsGroupBy()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsGroupBy",
+          methodArgs = {}
+        )
+    })
     public void test_supportsGroupBy() throws SQLException {
         insertNewRecord();
 
@@ -1752,6 +2775,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsGroupByBeyondSelect()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsGroupByBeyondSelect",
+          methodArgs = {}
+        )
+    })
     public void test_supportsGroupByBeyondSelect() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1759,6 +2791,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsGroupByUnrelated()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsGroupByUnrelated",
+          methodArgs = {}
+        )
+    })
     public void test_supportsGroupByUnrelated() throws SQLException {
         insertNewRecord();
 
@@ -1780,6 +2821,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsIntegrityEnhancementFacility()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsIntegrityEnhancementFacility",
+          methodArgs = {}
+        )
+    })
     public void test_supportsIntegrityEnhancementFacility() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1787,6 +2837,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsLikeEscapeClause()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsLikeEscapeClause",
+          methodArgs = {}
+        )
+    })
     public void test_supportsLikeEscapeClause() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1794,6 +2853,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsLimitedOuterJoins()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsLimitedOuterJoins",
+          methodArgs = {}
+        )
+    })
     public void test_supportsLimitedOuterJoins() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1801,6 +2869,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMinimumSQLGrammar()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMinimumSQLGrammar",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMinimumSQLGrammar() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1808,6 +2885,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMixedCaseIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMixedCaseIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMixedCaseIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1815,6 +2901,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMixedCaseQuotedIdentifiers()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMixedCaseQuotedIdentifiers",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMixedCaseQuotedIdentifiers() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1822,6 +2917,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMultipleOpenResults()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMultipleOpenResults",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMultipleOpenResults() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1829,6 +2933,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMultipleResultSets()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMultipleResultSets",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMultipleResultSets() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1836,6 +2949,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsMultipleTransactions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsMultipleTransactions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsMultipleTransactions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1843,6 +2965,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsNamedParameters()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsNamedParameters",
+          methodArgs = {}
+        )
+    })
     public void test_supportsNamedParameters() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1850,6 +2981,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsNonNullableColumns()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsNonNullableColumns",
+          methodArgs = {}
+        )
+    })
     public void test_supportsNonNullableColumns() throws SQLException {
         assertTrue(
                 "columns in this database may not be defined as non-nullable",
@@ -1859,6 +2999,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOpenCursorsAcrossCommit()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOpenCursorsAcrossCommit",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOpenCursorsAcrossCommit() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1866,6 +3015,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOpenCursorsAcrossRollback()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOpenCursorsAcrossRollback",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOpenCursorsAcrossRollback() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1873,6 +3031,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOpenStatementsAcrossCommit()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOpenStatementsAcrossCommit",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOpenStatementsAcrossCommit() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1880,6 +3047,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOpenStatementsAcrossRollback()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOpenStatementsAcrossRollback",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOpenStatementsAcrossRollback() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1887,6 +3063,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOrderByUnrelated()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOrderByUnrelated",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOrderByUnrelated() throws SQLException {
         insertNewRecord();
 
@@ -1908,6 +3093,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsOuterJoins()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsOuterJoins",
+          methodArgs = {}
+        )
+    })
     public void test_supportsOuterJoins() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1915,6 +3109,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsPositionedDelete()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsPositionedDelete",
+          methodArgs = {}
+        )
+    })
     public void test_supportsPositionedDelete() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1922,6 +3125,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsPositionedUpdate()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsPositionedUpdate",
+          methodArgs = {}
+        )
+    })
     public void test_supportsPositionedUpdate() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1929,6 +3141,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsResultSetConcurrency(int, int)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsResultSetConcurrency",
+          methodArgs = {int.class, int.class}
+        )
+    })
     public void test_supportsResultSetConcurrencyII() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1936,6 +3157,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsResultSetHoldability(int)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsResultSetHoldability",
+          methodArgs = {int.class}
+        )
+    })
     public void test_supportsResultSetHoldabilityI() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1943,6 +3173,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsResultSetType(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "supportsResultSetType",
+          methodArgs = {int.class}
+        )
+    })
     public void test_supportsResultSetTypeI() throws SQLException {
         // TODO not supported
 //        assertFalse("database supports TYPE_FORWARD_ONLY type", meta
@@ -1958,6 +3198,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSavepoints()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSavepoints",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSavepoints() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1965,6 +3214,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSchemasInDataManipulation()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSchemasInDataManipulation",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSchemasInDataManipulation() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1972,6 +3230,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSchemasInIndexDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSchemasInIndexDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSchemasInIndexDefinitions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1979,6 +3246,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSchemasInPrivilegeDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSchemasInPrivilegeDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSchemasInPrivilegeDefinitions()
             throws SQLException {
         // TODO: JDBC does not implement this functionality
@@ -1987,6 +3263,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSchemasInProcedureCalls()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSchemasInProcedureCalls",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSchemasInProcedureCalls() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -1994,6 +3279,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSchemasInTableDefinitions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSchemasInTableDefinitions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSchemasInTableDefinitions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2001,6 +3295,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSelectForUpdate()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSelectForUpdate",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSelectForUpdate() throws SQLException {
         insertNewRecord();
 
@@ -2022,6 +3325,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsStatementPooling()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsStatementPooling",
+          methodArgs = {}
+        )
+    })
     public void test_supportsStatementPooling() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2029,6 +3341,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsStoredProcedures()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsStoredProcedures",
+          methodArgs = {}
+        )
+    })
     public void test_supportsStoredProcedures() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2036,6 +3357,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSubqueriesInComparisons()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSubqueriesInComparisons",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSubqueriesInComparisons() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2043,6 +3373,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSubqueriesInExists()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSubqueriesInExists",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSubqueriesInExists() throws SQLException {
         insertNewRecord();
 
@@ -2066,6 +3405,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSubqueriesInIns()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSubqueriesInIns",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSubqueriesInIns() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2073,6 +3421,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsSubqueriesInQuantifieds()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsSubqueriesInQuantifieds",
+          methodArgs = {}
+        )
+    })
     public void test_supportsSubqueriesInQuantifieds() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2080,6 +3437,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsTableCorrelationNames()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "supportsTableCorrelationNames",
+          methodArgs = {}
+        )
+    })
     public void test_supportsTableCorrelationNames() throws SQLException {
         insertNewRecord();
 
@@ -2105,6 +3471,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsTransactionIsolationLevel(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "supportsTransactionIsolationLevel",
+          methodArgs = {int.class}
+        )
+    })
     public void test_supportsTransactionIsolationLevelI() throws SQLException {
         assertFalse("database supports TRANSACTION_NONE isolation level", meta
                 .supportsTransactionIsolationLevel(Connection.TRANSACTION_NONE));
@@ -2132,6 +3508,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsTransactions()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsTransactions",
+          methodArgs = {}
+        )
+    })
     public void test_supportsTransactions() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2139,6 +3524,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsUnion()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsUnion",
+          methodArgs = {}
+        )
+    })
     public void test_supportsUnion() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2146,6 +3540,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#supportsUnionAll()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "supportsUnionAll",
+          methodArgs = {}
+        )
+    })
     public void test_supportsUnionAll() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2153,6 +3556,16 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#updatesAreDetected(int)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed. " +
+                  "Verification with invalid parameters missed.",
+      targets = {
+        @TestTarget(
+          methodName = "updatesAreDetected",
+          methodArgs = {int.class}
+        )
+    })
     public void test_updatesAreDetectedI() throws SQLException {
         assertFalse(
                 "visible row update can be detected for TYPE_FORWARD_ONLY type",
@@ -2170,6 +3583,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#usesLocalFilePerTable()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "usesLocalFilePerTable",
+          methodArgs = {}
+        )
+    })
     public void test_usesLocalFilePerTable() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
@@ -2177,6 +3599,15 @@ public class DatabaseMetaDataTest extends TestCase {
     /**
      * @tests java.sql.DatabaseMetaData#usesLocalFiles()
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "usesLocalFiles",
+          methodArgs = {}
+        )
+    })
     public void test_usesLocalFiles() throws SQLException {
         // TODO: JDBC does not implement this functionality
     }
diff --git a/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java b/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java
index f00a7cf..621cf60 100755
--- a/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java
+++ b/sql/src/test/java/tests/java/sql/DeleteFunctionalityTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -30,7 +35,7 @@ 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;
@@ -121,6 +126,15 @@ public class DeleteFunctionalityTest extends TestCase {
      * @tests DeleteFunctionalityTest#testDelete1(). Deletes row with no
      *        referencing ones and RESTRICT action
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Deletes row with no referencing ones and RESTRICT action",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testDelete1() throws SQLException {
         DatabaseCreator.fillFKStrictTable(conn);
         statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
@@ -147,6 +161,15 @@ public class DeleteFunctionalityTest extends TestCase {
      * @tests DeleteFunctionalityTest#testDelete3(). Deletes all referencing
      *        rows and then deletes referenced one
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Deletes all referencing rows and then deletes referenced one",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testDelete3() throws SQLException {
         statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
                 + " WHERE name_id = 1;");
@@ -158,6 +181,15 @@ public class DeleteFunctionalityTest extends TestCase {
      * @tests DeleteFunctionalityTest#testDelete4(). Deletes row with no
      *        referencing ones and CASCADE action
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Deletes row with no referencing ones and CASCADE action",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testDelete4() throws SQLException {
         DatabaseCreator.fillFKCascadeTable(conn);
         statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
@@ -169,6 +201,21 @@ public class DeleteFunctionalityTest extends TestCase {
      *        referencing ones and CASCADE action - expecting all referencing
      *        rows will also be deleted
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Attempts to delete row with referencing " +
+                "ones and CASCADE action - expecting all referencing rows " +
+                "will also be deleted",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testDelete5() throws SQLException {
         statement.execute("DELETE FROM " + DatabaseCreator.PARENT_TABLE
                 + " WHERE id = 1;");
@@ -201,6 +248,15 @@ public class DeleteFunctionalityTest extends TestCase {
      * @tests DeleteFunctionalityTest#testDelete7(). Deletes rows using
      *        PreparedStatement
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Deletes rows using PreparedStatement",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testDelete7() throws SQLException {
         DatabaseCreator.fillTestTable5(conn);
         PreparedStatement stat = conn.prepareStatement("DELETE FROM "
diff --git a/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java b/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java
index 7ad2d3e..da9e045 100755
--- a/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java
+++ b/sql/src/test/java/tests/java/sql/InsertFunctionalityTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -31,6 +36,7 @@ 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;
@@ -137,6 +143,16 @@ public class InsertFunctionalityTest extends TestCase {
      * @tests InsertFunctionalityTest#testInsert1(). Attempts to insert row into
      *        table with integrity checking
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Attempts to insert row into " + 
+                  "table with integrity checking",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsert1() throws SQLException {
         DatabaseCreator.fillParentTable(conn);
         DatabaseCreator.fillFKStrictTable(conn);
@@ -152,6 +168,16 @@ public class InsertFunctionalityTest extends TestCase {
      *        table with integrity checking when row has incorrect foreign key
      *        value - expecting SQLException
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Attempts to insert row into table with " +
+                "integrity checking when row has incorrect foreign key value - expecting SQLException",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsert2() throws SQLException {
         DatabaseCreator.fillParentTable(conn);
         DatabaseCreator.fillFKStrictTable(conn);
@@ -178,6 +204,19 @@ public class InsertFunctionalityTest extends TestCase {
      * @tests InsertFunctionalityTest#testInsert3(). Tests INSERT ... SELECT
      *        functionality
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Tests INSERT ... SELECT functionality",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsert3() throws SQLException {
         DatabaseCreator.fillParentTable(conn);
         DatabaseCreator.fillFKStrictTable(conn);
@@ -195,6 +234,19 @@ public class InsertFunctionalityTest extends TestCase {
      * @tests InsertFunctionalityTest#testInsert4(). Tests INSERT ... SELECT
      *        with expressions in SELECT query
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Tests INSERT ... SELECT with expressions in SELECT query",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsert4() throws SQLException {
         DatabaseCreator.fillSimpleTable1(conn);
         statement.execute("INSERT INTO " + DatabaseCreator.SIMPLE_TABLE2
@@ -213,6 +265,19 @@ public class InsertFunctionalityTest extends TestCase {
      * @tests InsertFunctionalityTest#testInsert5(). Inserts multiple rows using
      *        UNION ALL
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Inserts multiple rows using UNION ALL",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsert5() throws SQLException {
         statement.execute("INSERT INTO " + DatabaseCreator.TEST_TABLE5
                 + " SELECT 1 as testId, 2 as testValue "
@@ -229,6 +294,15 @@ public class InsertFunctionalityTest extends TestCase {
      * @tests InsertFunctionalityTest#testInsert6(). Tests INSERT with
      *        PreparedStatement
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Tests INSERT with PreparedStatement",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testInsertPrepared() throws SQLException {
         PreparedStatement stat = conn.prepareStatement("INSERT INTO "
                 + DatabaseCreator.TEST_TABLE5 + " VALUES(?, ?)");
diff --git a/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java b/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java
index b88aa4e..6770624 100755
--- a/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java
+++ b/sql/src/test/java/tests/java/sql/MultiThreadAccessTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.math.BigDecimal;
 import java.sql.Connection;
 import java.sql.ResultSet;
@@ -32,6 +37,7 @@ import junit.framework.TestSuite;
 
 import tests.support.ThreadPool;
 
+@TestTargetClass(Statement.class)
 public class MultiThreadAccessTest extends TestCase {
 
     private static Connection conn;
@@ -127,6 +133,16 @@ public class MultiThreadAccessTest extends TestCase {
      * 
      * @throws SQLException
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: A few threads execute select operation " + 
+                "in the same time for one table in the database.",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_MultipleAccessToOneTable() throws SQLException {
         for (int i = 0; i < numThreads; i++) {
             threadPool.runTask(createTask1(i));
@@ -140,6 +156,16 @@ public class MultiThreadAccessTest extends TestCase {
      * 
      * @throws SQLException
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: A few threads execute select operation " +
+                  "in the same time for different tables in the database",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_MultipleAccessToSeveralTables() throws SQLException {
         threadPool.runTask(createTask1(1));
         threadPool.runTask(createTask2(2));
@@ -153,6 +179,16 @@ public class MultiThreadAccessTest extends TestCase {
      * 
      * @throws SQLException
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: A few threads execute update, insert " + 
+                "and delete operations in the same time for one table in the database",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_MultipleOperationsInSeveralTables() throws SQLException {
         int id1 = numOfRecords - 1;
         threadPool.runTask(createTask4(id1));
@@ -208,6 +244,16 @@ public class MultiThreadAccessTest extends TestCase {
      * 
      * @throws SQLException
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functional test: A few threads execute update operation " +
+                "in the same time for one tables in the database",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_MultipleUpdatesInOneTables() throws SQLException {
         int id = 1;
         String field = "field3";
diff --git a/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java b/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java
index a0ded6a..9c6bf20 100755
--- a/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java
+++ b/sql/src/test/java/tests/java/sql/SelectFunctionalityTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.CharArrayReader;
 import java.math.BigDecimal;
 import java.sql.Connection;
@@ -37,6 +42,7 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+@TestTargetClass(Statement.class)
 public class SelectFunctionalityTest extends TestCase {
 
     private static Connection conn;
@@ -137,6 +143,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectSimple(). Selects all records
      *        from the table
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects all records from the table",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectSimple() throws SQLException {
         String sql = "SELECT * FROM " + DatabaseCreator.TEST_TABLE2;
         ResultSet result = statement.executeQuery(sql);
@@ -180,6 +195,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectPrepared(). Selects all records
      *        from the table using parametric query
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects all records from the table using parametric query",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectPrepared() throws SQLException {
         String sql = "SELECT finteger, ftext, fcharacter, fdecimal, fnumeric,"
                 + " fsmallint, ffloat, freal, fdouble, fdate, ftime" + " FROM "
@@ -242,6 +266,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SubSelect(). Selects records from the
      *        table using subselect
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from the table using subselect",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SubSelect() throws SQLException {
         String sql = "SELECT finteger," + " (SELECT ftext FROM "
                 + DatabaseCreator.TEST_TABLE2 + " WHERE finteger = 1) as ftext"
@@ -271,6 +304,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records
      *        from a few tables
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a few tables",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectThreeTables() throws SQLException {
         String sql = "SELECT onum, " + DatabaseCreator.ORDERS_TABLE + ".cnum"
                 + " FROM " + DatabaseCreator.SALESPEOPLE_TABLE + ", "
@@ -309,6 +351,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectThreeTables(). Selects records
      *        from a table using union
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using union",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectUnionItself() throws SQLException {
         String sql = "SELECT b.cnum, b.cname" + " FROM "
                 + DatabaseCreator.CUSTOMERS_TABLE + " a, "
@@ -337,6 +388,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectLeftOuterJoin(). Selects
      *        records from a table using left join
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using left join",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {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 "
@@ -400,6 +460,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectGroupBy(). Selects records from
      *        a table using group by
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using group by",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectGroupBy() throws SQLException {
         String selectQuery = "SELECT rating, SUM(snum) AS sum FROM "
                 + DatabaseCreator.CUSTOMERS_TABLE + " GROUP BY rating";
@@ -427,6 +496,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectOrderBy(). Selects records from
      *        a table using order by
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using order by",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectOrderBy() throws SQLException {
         String selectQuery = "SELECT onum FROM " + DatabaseCreator.ORDERS_TABLE
                 + " ORDER BY onum";
@@ -460,6 +538,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectDistinct(). Selects records
      *        from a table using distinct
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using distinct",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectDistinct() throws SQLException {
         String selectQuery = "SELECT DISTINCT rating FROM "
                 + DatabaseCreator.CUSTOMERS_TABLE;
@@ -484,7 +571,16 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectAgregateFunctions(). Selects
      *        records from a table using agregate functions
      */
-    public void test_SelectAgregateFunctions() throws SQLException {
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using agregate functions",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {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 "
@@ -521,6 +617,15 @@ public class SelectFunctionalityTest extends TestCase {
      * @tests SelectFunctionalityTest#test_SelectHaving(). Selects records from
      *        a table using having
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Selects records from a table using having",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void test_SelectHaving() throws SQLException {
         String selectQuery = "SELECT snum, max(amt) AS max FROM "
                 + DatabaseCreator.ORDERS_TABLE
diff --git a/sql/src/test/java/tests/java/sql/StressTest.java b/sql/src/test/java/tests/java/sql/StressTest.java
index fbafe82..fc87487 100755
--- a/sql/src/test/java/tests/java/sql/StressTest.java
+++ b/sql/src/test/java/tests/java/sql/StressTest.java
@@ -16,8 +16,14 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
+import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
@@ -32,6 +38,7 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+@TestTargetClass(Connection.class)
 public class StressTest extends TestCase {
     Vector<Connection> vc = new Vector<Connection>();
 
@@ -108,6 +115,15 @@ public class StressTest extends TestCase {
      * @tests StressTest#testManyConnectionsUsingOneThread(). Create many
      *        connections to the DataBase using one thread.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Stress test: Create many connections to the DataBase using one thread",
+      targets = {
+        @TestTarget(
+          methodName = "getMetaData",
+          methodArgs = {}
+        )
+    })
     public void testManyConnectionsUsingOneThread() {
         try {
             int maxConnections = getConnectionNum();
@@ -123,6 +139,15 @@ public class StressTest extends TestCase {
      * @tests StressTest#testManyConnectionsUsingManyThreads(). Create many
      *        connections to the DataBase using some threads.
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Stress test: Create many connections to the DataBase using some threads",
+      targets = {
+        @TestTarget(
+          methodName = "DriverManager.getConnection",
+          methodArgs = {String.class, String.class, String.class}
+        )
+    })
     public void testManyConnectionsUsingManyThreads() {
         int numTasks = getConnectionNum();
 
@@ -152,6 +177,15 @@ public class StressTest extends TestCase {
      * @tests StressTest#testInsertOfManyRowsUsingOneThread(). Insert a lot of
      *        records to the DataBase using a maximum number of connections.
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "",
+          methodArgs = {}
+        )
+    })
     public void testInsertOfManyRowsUsingOneThread() {
         // TODO Crashes VM. Fix later.
         /*
@@ -172,6 +206,15 @@ public class StressTest extends TestCase {
     /**
      * @tests
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Empty test",
+      targets = {
+        @TestTarget(
+          methodName = "",
+          methodArgs = {}
+        )
+    })
     public void testInsertOfManyRowsUsingManyThreads() {
         // TODO Crashes VM. Fix later.
         /*
diff --git a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java
index b9761cd..e4e6e49 100755
--- a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java
+++ b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.math.BigDecimal;
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
@@ -31,6 +36,7 @@ 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;
@@ -119,6 +125,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate1(). Updates all values in one
      *        column in the table
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates all values in one column in the table",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate1() {
         String newValue = "newValue";
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
@@ -144,6 +163,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate2(). Updates values in one
      *        column in the table using where condition in update command
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates values in one column in the table using where condition in update command",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate2() {
         String newValue = "newValue";
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
@@ -176,6 +208,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate3(). Updates values in a several
      *        columns in the table
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates values in a several columns in the table",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate3() {
         int newValue1 = -1;
         int newValue2 = -2;
@@ -205,6 +250,20 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate4(). Updates values in a several
      *        columns in the table using where condition in update command
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates values in a several " + 
+                  "columns in the table using where condition in update command",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate4() {
         int newValue1 = -1;
         int newValue2 = -2;
@@ -244,6 +303,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate5(). Updates values in one
      *        columns in the table using condition
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates values in one columns in the table using condition",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate5() {
         int factor = 3;
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
@@ -282,6 +354,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate6(). Sets value of field2 to
      *        default
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Sets value of field2 to default",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate6() {
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
                 + " SET field2='1'";
@@ -309,6 +394,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate7(). Updates records in the
      *        table using subquery in update command
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates records in the table using subquery in update command",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate7() {
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
                 + " SET field2='1' WHERE id < ( SELECT COUNT(*) FROM "
@@ -342,6 +440,19 @@ public class UpdateFunctionalityTest extends TestCase {
      * @tests UpdateFunctionalityTest#testUpdate8(). Sets value of field2 to
      *        NULL
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Sets value of field2 to NULL",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate8() {
         String updateQuery = "UPDATE " + DatabaseCreator.TEST_TABLE1
                 + " SET field2=NULL";
diff --git a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java
index 7bcbff6..e64ecb2 100755
--- a/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java
+++ b/sql/src/test/java/tests/java/sql/UpdateFunctionalityTest2.java
@@ -16,6 +16,11 @@
 
 package tests.java.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.PreparedStatement;
@@ -31,6 +36,7 @@ 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;
@@ -137,6 +143,15 @@ public class UpdateFunctionalityTest2 extends TestCase {
      * @tests UpdateFunctionalityTest2#testUpdate1(). Updates row with no
      *        referencing ones and RESTRICT action
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates row with no referencing ones and RESTRICT action",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate1() throws SQLException {
         DatabaseCreator.fillFKStrictTable(conn);
         statement.execute("UPDATE " + DatabaseCreator.PARENT_TABLE
@@ -165,6 +180,15 @@ public class UpdateFunctionalityTest2 extends TestCase {
      * @tests UpdateFunctionalityTest2#testUpdate3(). Deletes all referencing
      *        rows and then updates referenced one
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Deletes all referencing rows and then updates referenced one",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate3() throws SQLException {
         DatabaseCreator.fillFKStrictTable(conn);
         statement.execute("DELETE FROM " + DatabaseCreator.FKSTRICT_TABLE
@@ -195,6 +219,20 @@ public class UpdateFunctionalityTest2 extends TestCase {
      *        referencing ones and CASCADE action - expecting that all
      *        referencing rows will also be updated
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates row with referencing ones and " +
+                "CASCADE action - expecting that all referencing rows will also be updated",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+      )
+    })
     public void testUpdate5() throws SQLException {
         DatabaseCreator.fillFKCascadeTable(conn);
         statement.execute("UPDATE " + DatabaseCreator.PARENT_TABLE
@@ -251,6 +289,19 @@ public class UpdateFunctionalityTest2 extends TestCase {
      * @tests UpdateFunctionalityTest2#testUpdate8(). Updates table using scalar
      *        subquery as new field value
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates table using scalar subquery as new field value",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        ),
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate8() throws SQLException {
         statement.execute("UPDATE " + DatabaseCreator.SIMPLE_TABLE3
                 + " SET speed = (SELECT MAX(speed) FROM "
@@ -272,6 +323,15 @@ public class UpdateFunctionalityTest2 extends TestCase {
      * @tests UpdateFunctionalityTest2#testUpdate9(). Updates table using
      *        PreparedStatement
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functionality test: Updates table using PreparedStatement",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
     public void testUpdate9() throws SQLException {
         DatabaseCreator.fillTestTable5(conn);
         PreparedStatement stat = conn.prepareStatement("UPDATE "
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..295af69
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/ConnectionEventListenerTest.java
@@ -0,0 +1,45 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies that the listener is notified when a connection closed regularly.",
+            targets = { @TestTarget(methodName = "testConnectionEventPooledConnection", 
+                                    methodArgs = {ConnectionEvent.class})                         
+            }
+    ) 
+    
+    public void testConnectionClosed() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @test {@link javax.sql.ConnectionEventListener#connectionErrorOccurred(ConnectionEvent)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies that the listener is notified when a connection is unavailable because an error has occurred.",
+            targets = { @TestTarget(methodName = "testConnectionEventPooledConnection", 
+                                    methodArgs = {ConnectionEvent.class})                         
+            }
+    )    
+    public void testConnectionErrorOccurred() {
+        fail("Not yet implemented"); // TODO
+    }
+
+}
diff --git a/sql/src/test/java/tests/javax/sql/ConnectionEventTest.java b/sql/src/test/java/tests/javax/sql/ConnectionEventTest.java
new file mode 100644
index 0000000..ea62edf
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/ConnectionEventTest.java
@@ -0,0 +1,64 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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)}
+     * @see {@link org.apache.harmony.sql.tests.javax.sql.ConnectionEventTest}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies ConnectionEvent() constructor for the normal case.",
+            targets = { @TestTarget(methodName = "testConnectionEventPooledConnection", 
+                                    methodArgs = {PooledConnection.class})                         
+            }
+    )  
+    
+    public void testConnectionEventPooledConnection() {
+        // delegate to package org.apache.harmony.sql.tests.javax.sql.
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#ConnectionEvent(PooledConnection, SQLException)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies ConnectionEvent() constructor for the abnormal case that an error has occurred on the pooled connection.",
+            targets = { @TestTarget(methodName = "testConnectionEventPooledConnection", 
+                                    methodArgs = {PooledConnection.class,SQLException.class})                         
+            }
+    )    
+    public void testConnectionEventPooledConnectionSQLException() {
+     // delegate to org.apache.harmony.sql.tests.javax.sql.
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionEvent#getSQLException()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "Verifies that a SQLException is thrown after an error has occurred in the connection pool.",
+            targets = { @TestTarget(methodName = "testGetSQLException", 
+                                    methodArgs = {})                         
+            }
+    )    
+    public void testGetSQLException() {
+        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..9cb5d12
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/ConnectionPoolDataSourceTest.java
@@ -0,0 +1,102 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getLoginTimeout",
+                                     methodArgs = {ConnectionPoolDataSource.class})
+            }
+    )
+    public void testGetLoginTimeout() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getLogWriter()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getLogWriter",
+                                     methodArgs = {ConnectionPoolDataSource.class})
+            }
+    )
+    public void testGetLogWriter() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getPooledConnection()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getPooledConnection",
+                                     methodArgs = {ConnectionPoolDataSource.class})
+            }
+    )
+    public void testGetPooledConnection() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#getPooledConnection(String, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getPooledConnection",
+                                     methodArgs = {ConnectionPoolDataSource.class})
+            }
+    )
+    public void testGetPooledConnectionStringString() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#setLoginTimeout(int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setLoginTimeout",
+                                     methodArgs = {int.class})
+            }
+    )
+    public void testSetLoginTimeout() {
+        fail("Not yet implemented"); // TODO
+    }
+
+    /**
+     * @tests {@link javax.sql.ConnectionPoolDataSource#setLogWriter(java.io.PrintWriter)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setLogWriter",
+                                     methodArgs = {PrintWriter.class})
+            }
+    )
+    public void testSetLogWriter() {
+        fail("Not yet implemented"); // TODO
+    }
+
+}
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..c534e6e
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/DataSourceTest.java
@@ -0,0 +1,100 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.DataSource;
+
+@TestTargetClass(DataSource.class)
+public class DataSourceTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.DataSource#getConnection()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getConnetion",
+                                     methodArgs = {})
+            }
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * @tests {@link javax.sql.DataSource#getConnection(String, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getConnection",
+                                     methodArgs = {String.class,String.class})
+            }
+    )
+    public void testGetConnectionStringString() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#getLoginTimeout()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getLoginTimeout",
+                                     methodArgs = {})
+            }
+    )
+    public void testGetLoginTimeout() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#getLogWriter()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getLogWriter",
+                                     methodArgs = {})
+            }
+    )
+    public void testGetLogWriter() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.DataSource#setLoginTimeout(int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setLoginTimeout",
+                                     methodArgs = {int.class})
+            }
+    )
+    public void testSetLoginTimeout() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.DataSource#setLogWriter(java.io.PrintWriter)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setLoginTimeout",
+                                     methodArgs = {int.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..614322a
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/PooledConnectionTest.java
@@ -0,0 +1,72 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.ConnectionEventListener;
+
+@TestTargetClass(PooledConnectionTest.class)
+public class PooledConnectionTest extends TestCase {
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#addConnectionEventListener(javax.sql.ConnectionEventListener)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "addConnectionEventListener",
+                                   methodArgs = {ConnectionEventListener.class})
+            }
+    )
+    public void testAddConnectionEventListener() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#close()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "close",
+                                   methodArgs = {})
+            }
+    )
+    public void testClose() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.PooledConnection#getConnection()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getConnection",
+                                   methodArgs = {})
+            }
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.PooledConnection#removeConnectionEventListener(ConnectionEventListener)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getConnection",
+                                   methodArgs = {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..1521554
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetInternalTest.java
@@ -0,0 +1,86 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getConnection",
+                                   methodArgs = {})
+            }
+    )
+    public void testGetConnection() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getOriginal()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getOriginal",
+                                   methodArgs = {})
+            }
+    )
+    public void testGetOriginal() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getOriginalRow()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getOriginalRow",
+                                   methodArgs = {})
+            }
+    )
+    public void testGetOriginalRow() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#getOriginalRow()}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getOriginalRow",
+                                   methodArgs = {})
+            }
+    )
+    public void testGetParams() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetInternal#setMetaData(javax.sql.RowSetMetaData)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "getOriginalRow",
+                                   methodArgs = {RowSetMetaData.class})
+            }
+    )
+    public void testSetMetaData() {
+        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..acaffb8
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetMetaDataTest.java
@@ -0,0 +1,258 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "etAutoIncrement",
+                                   methodArgs = {int.class,boolean.class})
+            }
+    )
+    public void testSetAutoIncrement() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCaseSensitive(int, boolean)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setCaseSensitive",
+                                   methodArgs = {int.class,boolean.class})
+            }
+    )
+    public void testSetCaseSensitive() {
+        fail("Not yet implemented");
+    }
+
+    
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCatalogName(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setCatalogName",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetCatalogName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnCount(int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnCount",
+                                   methodArgs = {int.class})
+            }
+    )
+    public void testSetColumnCount() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnDisplaySize(int, int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnDisplaySize",
+                                   methodArgs = {int.class,int.class})
+            }
+    )
+    public void testSetColumnDisplaySize() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnLabel(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setCaseSensitive",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetColumnLabel() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnName(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnName",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetColumnName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnType(int, int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnName",
+                                   methodArgs = {int.class,int.class})
+            }
+    )
+    public void testSetColumnType() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setColumnTypeName(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnTypeName",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetColumnTypeName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setCurrency(int, boolean)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setCurrency",
+                                   methodArgs = {int.class,boolean.class})
+            }
+    )
+    public void testSetCurrency() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setNullable(int, int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setNullable",
+                                   methodArgs = {int.class,int.class})
+            }
+    )
+    public void testSetNullable() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setPrecision(int, int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnName",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetPrecision() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setScale(int, int)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setScale",
+                                   methodArgs = {int.class,int.class})
+            }
+    )
+    public void testSetScale() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSchemaName(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setSchemaName",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetSchemaName() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSearchable(int, boolean)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setSearchable",
+                                   methodArgs = {int.class,String.class})
+            }
+    )
+    public void testSetSearchable() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setSigned(int, boolean)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setSigned",
+                                   methodArgs = {int.class,boolean.class})
+            }
+    )
+    public void testSetSigned() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSetMetaData#setTableName(int, String)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setTableName",
+                                   methodArgs = {int.class,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..3519ec5
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetReaderTest.java
@@ -0,0 +1,30 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnName",
+                                   methodArgs = {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..4ec1db1
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetTest.java
@@ -0,0 +1,295 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetClass;
+
+import junit.framework.TestCase;
+
+import javax.sql.RowSet;
+import javax.sql.RowSetListener;
+
+/**
+ * Annotation conventions for setters and getters?
+ * @author andrea.groessbauer@noser.com
+ *
+ */
+@TestTargetClass(RowSet.class)
+public class RowSetTest extends TestCase {
+
+    /**
+     * Sets up the mock RowSet.
+     */
+    @Override
+    protected void setUp() {
+        // Reuse org.apache.harmony.sql.tests.javax.sql.Impl_RowSet.java
+    }
+    
+    /**
+     * @tests {@link javax.sql.RowSet#addRowSetListener(javax.sql.RowSetListener)}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = { @TestTarget(methodName = "addRowSetListener", 
+                                    methodArgs = {RowSetListener.class})                         
+            }
+    )    
+    public void testAddRowSetListener() {
+        fail("Not yet implemented");
+    }
+    
+    /**
+     * @tests {@link javax.sql.RowSet#clearParameters()}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = { @TestTarget(methodName = "clearParameters", 
+                                    methodArgs = {})                         
+            }
+    )    
+    public void testClearParameters() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#addRowSetListener(javax.sql.RowSetListener)}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = { @TestTarget(methodName = "addRowSetListener", 
+                                    methodArgs = {RowSetListener.class})                         
+            }
+    )    
+    public void testExecute() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#getCommand()}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = { @TestTarget(methodName = "getCommand", 
+                                    methodArgs = {})                         
+            }
+    )    
+    public void testSetGetCommand() {
+        fail("Not yet implemented");
+    }
+
+    /**
+     * @tests {@link javax.sql.RowSet#getDataSourceName()}.
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = { @TestTarget(methodName = "getDataSourceName", 
+                                    methodArgs = {})                         
+            }
+    )    
+    public void testSetGetDataSourceName() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetEscapeProcessing() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetMaxFieldSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetMaxRows() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetPassword() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetQueryTimeout() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetTransactionIsolation() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetTypeMap() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetUrl() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetUsername() {
+        fail("Not yet implemented");
+    }
+
+    public void testIsReadOnly() {
+        fail("Not yet implemented");
+    }
+
+    public void testRemoveRowSetListener() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetArray() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetAsciiStream() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetBigDecimal() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetBinaryStream() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetBlob() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetBoolean() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetByte() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetBytes() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetCharacterStream() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetClob() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetConcurrency() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetDateIntDate() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetDateIntDateCalendar() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetDouble() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetFloat() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetLong() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetGetMaxFieldSize() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetNullIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetNullIntIntString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetObjectIntObject() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetObjectIntObjectInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetGetObjectIntObjectIntInt() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetPassword() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetQueryTimeout() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetReadOnly() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetRef() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetShort() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetString() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTimeIntTime() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTimeIntTimeCalendar() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTimestampIntTimestamp() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTimestampIntTimestampCalendar() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTransactionIsolation() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetType() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetTypeMap() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetUrl() {
+        fail("Not yet implemented");
+    }
+
+    public void testSetUsername() {
+        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..c6b51ff
--- /dev/null
+++ b/sql/src/test/java/tests/javax/sql/RowSetWriterTest.java
@@ -0,0 +1,30 @@
+package tests.javax.sql;
+
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+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)}
+     */
+    @TestInfo(
+            level = TestLevel.TODO,
+            purpose = "",
+            targets = {@TestTarget(methodName = "setColumnName",
+                                   methodArgs = {RowSetInternal.class})
+            }
+    )
+    public void testWriteData() {
+        fail("Not yet implemented");
+    }
+
+}
diff --git a/sql/src/test/java/tests/sql/ConnectionTest.java b/sql/src/test/java/tests/sql/ConnectionTest.java
index ba6fff2..64d78d2 100755
--- a/sql/src/test/java/tests/sql/ConnectionTest.java
+++ b/sql/src/test/java/tests/sql/ConnectionTest.java
@@ -16,6 +16,11 @@
 
 package tests.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.sql.Connection;
 import java.sql.DatabaseMetaData;
 import java.sql.SQLWarning;
@@ -29,11 +34,21 @@ import java.sql.CallableStatement;
 
 import junit.framework.Test;
 
+@TestTargetClass(Connection.class)
 public class ConnectionTest extends SQLTest {
 
     /**
      * @test java.sql.Connection#createStatement()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "createStatement",
+          methodArgs = {}
+        )
+    })
     public void testCreateStatement() {
 
         Statement statement = null;
@@ -57,6 +72,15 @@ public class ConnectionTest extends SQLTest {
      * @test java.sql.Connection#createStatement(int resultSetType, int
      *       resultSetConcurrency)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "createStatement",
+          methodArgs = {int.class, int.class}
+        )
+    })
     public void testCreateStatement_int_int() {
         Statement st = null;
         ResultSet rs = null;
@@ -135,14 +159,14 @@ public class ConnectionTest extends SQLTest {
         }
 
         try {
-	    // exception is not specified for this case
+        // exception is not specified for this case
             conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, -1);
         } catch (SQLException sqle) {
             // expected
         }
 
         try {
-	    // exception is not specified for this case
+        // exception is not specified for this case
             conn.createStatement(Integer.MIN_VALUE, ResultSet.CONCUR_READ_ONLY);
         } catch (SQLException sqle) {
             // expected
@@ -153,6 +177,15 @@ public class ConnectionTest extends SQLTest {
      * @test java.sql.Connection#createStatement(int resultSetType, int
      *       resultSetConcurrency, int resultSetHoldability)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "createStatement",
+          methodArgs = {int.class, int.class, int.class}
+        )
+    })
     public void testCreateStatement_int_int_int() {
         Statement st = null;
         try {
@@ -213,6 +246,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#getMetaData()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMetaData",
+          methodArgs = {}
+        )
+    })
     public void testGetMetaData() {
         try {
             DatabaseMetaData md = conn.getMetaData();
@@ -325,6 +367,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#getAutoCommit()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getAutoCommit",
+          methodArgs = {}
+        )
+    })
     public void testGetAutoCommit() {
         try {
             conn.setAutoCommit(true);
@@ -342,6 +393,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#setAutoCommit(boolean)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "setAutoCommit",
+          methodArgs = {boolean.class}
+        )
+    })
     public void testSetAutoCommit() {
         Statement st = null;
         ResultSet rs = null;
@@ -390,6 +450,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#isReadOnly()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "isReadOnly",
+          methodArgs = {}
+        )
+    })
     public void testIsReadOnly() {
         try {
             conn.setReadOnly(true);
@@ -408,7 +477,16 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#setReadOnly(boolean)
      */
-    public void testSetReadOnly() {
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setReadOnly",
+          methodArgs = {boolean.class}
+        )
+    })
+    public void _testSetReadOnly() {
         Statement st = null;
         try {
             conn.setReadOnly(true);
@@ -443,6 +521,15 @@ public class ConnectionTest extends SQLTest {
      * 
      * TODO ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getHoldability",
+          methodArgs = {}
+        )
+    })
     public void testGetHoldability() {
         try {
  //           conn.setHoldability(ResultSet.CLOSE_CURSORS_AT_COMMIT);
@@ -461,6 +548,15 @@ public class ConnectionTest extends SQLTest {
      * 
      * TODO ResultSet.CLOSE_CURSORS_AT_COMMIT is not supported
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setHoldability",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetHoldability() {
         Statement st = null;
         try {
@@ -501,6 +597,15 @@ public class ConnectionTest extends SQLTest {
      * 
      * TODO only Connection.TRANSACTION_SERIALIZABLE is supported
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTransactionIsolation",
+          methodArgs = {}
+        )
+    })
     public void testGetTransactionIsolation() {
         try {
 //            conn
@@ -527,6 +632,15 @@ public class ConnectionTest extends SQLTest {
      * 
      * TODO only Connection.TRANSACTION_SERIALIZABLE is supported
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "setTransactionIsolation",
+          methodArgs = {int.class}
+        )
+    })
     public void testSetTransactionIsolation() {
         try {
 //            conn
@@ -1045,6 +1159,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#commit()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "commit",
+          methodArgs = {}
+        )
+    })
     public void testCommit() {
         Statement st = null;
         Statement st1 = null;
@@ -1123,6 +1246,15 @@ public class ConnectionTest extends SQLTest {
     /**
      * @test java.sql.Connection#rollback()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "rollback",
+          methodArgs = {}
+        )
+    })
     public void testRollback() {
         Statement st = null;
         Statement st1 = null;
diff --git a/sql/src/test/java/tests/sql/PreparedStatementTest.java b/sql/src/test/java/tests/sql/PreparedStatementTest.java
index 1e6b124..865a4c3 100755
--- a/sql/src/test/java/tests/sql/PreparedStatementTest.java
+++ b/sql/src/test/java/tests/sql/PreparedStatementTest.java
@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
-package tests.sql;
+package tests.sql; 
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
 
 import java.math.BigDecimal;
 import java.sql.ParameterMetaData;
@@ -31,6 +36,7 @@ import java.util.Calendar;
 import java.util.Locale;
 import java.util.TimeZone;
 
+@TestTargetClass(PreparedStatement.class)
 public class PreparedStatementTest extends SQLTest {
 
     String queryAllSelect = "select * from type";
@@ -103,6 +109,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#addBatch()
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "addBatch",
+          methodArgs = {}
+        )
+    })
     public void testAddBatch() throws SQLException {
         PreparedStatement ps = null;
         try {
@@ -364,7 +379,16 @@ public class PreparedStatementTest extends SQLTest {
      * it is possible to invoke the method getMetaData on a 
      * PreparedStatement object rather than waiting to execute it.
      */
-    public void testGetMetaData() {
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getMetaData",
+          methodArgs = {}
+        )
+    })
+    public void _testGetMetaData() {
         PreparedStatement ps = null;
         try {
             String query = "update zoo set name='Masha', family='cat' where id=?;";
@@ -507,6 +531,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setInt(int parameterIndex, int x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setInt",
+          methodArgs = {int.class, int.class}
+        )
+    })
     public void testSetInt() throws SQLException {
         createTables();
         PreparedStatement ps = null;
@@ -577,6 +610,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setLong(int parameterIndex, long x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setLong",
+          methodArgs = {int.class, long.class}
+        )
+    })
     public void testSetLong() {
         createTables();
         PreparedStatement ps = null;
@@ -650,6 +692,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setFloat(int parameterIndex, float x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setFloat",
+          methodArgs = {int.class, float.class}
+        )
+    })
     public void testSetFloat() {
         float value1 = 12345678.12345689f;
         float value2 = -12345678.12345689f;
@@ -720,6 +771,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setDouble(int parameterIndex, double x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setDouble",
+          methodArgs = {int.class, double.class}
+        )
+    })
     public void testSetDouble() {
         createTables();
         PreparedStatement ps = null;
@@ -791,6 +851,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setString",
+          methodArgs = {int.class, String.class}
+        )
+    })
     public void testSetString_charField() {
         createTables();
         PreparedStatement ps = null;
@@ -891,6 +960,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setString",
+          methodArgs = {int.class, String.class}
+        )
+    })
     public void testSetString_tinyTextField() {
         createTables();
         PreparedStatement ps = null;
@@ -993,6 +1071,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setString",
+          methodArgs = {int.class, String.class}
+        )
+    })
     public void testSetString_textField() {
         createTables();
         PreparedStatement ps = null;
@@ -1098,6 +1185,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setString",
+          methodArgs = {int.class, String.class}
+        )
+    })
     public void testSetString_mediumTextField() {
         createTables();
         PreparedStatement ps = null;
@@ -1191,6 +1287,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setString(int parameterIndex, String x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setString",
+          methodArgs = {int.class, String.class}
+        )
+    })
     public void testSetString_longTextField() {
         createTables();
         PreparedStatement ps = null;
@@ -1284,6 +1389,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setShort(int parameterIndex, short x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setShort",
+          methodArgs = {int.class, short.class}
+        )
+    })
     public void testSetShort() {
         createTables();
         PreparedStatement ps = null;
@@ -1382,6 +1496,15 @@ public class PreparedStatementTest extends SQLTest {
      * @test java.sql.PreparedStatement#setBoolean(int parameterIndex, boolean
      *       x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setBoolean",
+          methodArgs = {int.class, boolean.class}
+        )
+    })
     public void testSetBoolean() {
         createTables();
         PreparedStatement ps = null;
@@ -1462,6 +1585,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setByte(int parameterIndex, byte x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setByte",
+          methodArgs = {int.class, byte.class}
+        )
+    })
     public void testSetByte() {
         createTables();
         PreparedStatement ps = null;
@@ -1542,6 +1674,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setBytes(int parameterIndex, byte[] x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setBytes",
+          methodArgs = {int.class, byte[].class}
+        )
+    })
     public void testSetBytes() {
 
         byte[] bytesArray = {1, 0};
@@ -1609,6 +1750,15 @@ public class PreparedStatementTest extends SQLTest {
      * @test java.sql.PreparedStatement#setBigDecimal(int parameterIndex,
      *       BigDecimal x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setBigDecimal",
+          methodArgs = {int.class, BigDecimal.class}
+        )
+    })
     public void testSetBigDecimal() {
 
         BigDecimal bd = new BigDecimal("50");
@@ -1674,6 +1824,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setDate(int parameterIndex, Date x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setDate",
+          methodArgs = {int.class, Date.class}
+        )
+    })
     public void testSetDate_int_Date() {
 
         Date[] dates = { new Date(1799, 05, 26), new Date(Integer.MAX_VALUE),
@@ -1747,6 +1906,15 @@ public class PreparedStatementTest extends SQLTest {
      * @test java.sql.PreparedStatement#setDate(int parameterIndex, Date x,
      *       Calendar cal)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setDate",
+          methodArgs = {int.class, Date.class, Calendar.class}
+        )
+    })
     public void testSetDate_int_Date_Calendar() {
 
         Calendar[] cals = { Calendar.getInstance(),
@@ -1825,6 +1993,15 @@ public class PreparedStatementTest extends SQLTest {
      * 
      * this test doesn't passed on RI
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed in exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setNull",
+          methodArgs = {int.class, int.class}
+        )
+    })
     public void testSetNull_int_int() {
         createTables();
         PreparedStatement ps = null;
@@ -1938,6 +2115,15 @@ public class PreparedStatementTest extends SQLTest {
      * 
      * this test doesn't pass on RI
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException case has incorrect structure",
+      targets = {
+        @TestTarget(
+          methodName = "setObject",
+          methodArgs = {int.class, Object.class}
+        )
+    })
     public void testSetObject_int_Object() {
         createTables();
         PreparedStatement ps = null;
@@ -2044,6 +2230,15 @@ public class PreparedStatementTest extends SQLTest {
      * 
      * this test doesn't pass on RI
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "setObject",
+          methodArgs = {int.class, Object.class, int.class}
+        )
+    })
     public void testSetObject_int_Object_int() {
         createTables();
         PreparedStatement ps = null;
@@ -2150,6 +2345,15 @@ public class PreparedStatementTest extends SQLTest {
      * 
      * this test doesn't pass on RI
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "setObject",
+          methodArgs = {int.class, Object.class, int.class, int.class}
+        )
+    })
     public void testSetObject_int_Object_int_int() {
         createTables();
         PreparedStatement ps = null;
@@ -2255,6 +2459,15 @@ public class PreparedStatementTest extends SQLTest {
     /**
      * @test java.sql.PreparedStatement#setTime(int parameterIndex, Time x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed from exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {int.class, Time.class}
+        )
+    })
     public void testSetTimeint_Time() {
 
         Time[] times = { new Time(24, 25, 26), new Time(Integer.MAX_VALUE),
@@ -2327,6 +2540,15 @@ public class PreparedStatementTest extends SQLTest {
      * @test java.sql.PreparedStatement#setTime(int parameterIndex, Time x,
      *       Calendar cal)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed from exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setTime",
+          methodArgs = {int.class, Time.class, Calendar.class}
+        )
+    })
     public void testSetTime_int_Time_Calendar() {
 
         Calendar[] cals = { Calendar.getInstance(),
@@ -2403,6 +2625,15 @@ public class PreparedStatementTest extends SQLTest {
      * @test java.sql.PreparedStatement#setTimestamp(int parameterIndex,
      *       Timestamp x)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "ps.execute() should be removed from exception part (for exception testing)",
+      targets = {
+        @TestTarget(
+          methodName = "setTimestamp",
+          methodArgs = {int.class, Timestamp.class}
+        )
+    })
     public void testSetTimestamp_int_Timestamp() {
 
         Timestamp[] timestamps = { new Timestamp(2007, 10, 17, 19, 06, 50, 23),
diff --git a/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java b/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java
index 1f9483b..4cd090f 100755
--- a/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java
+++ b/sql/src/test/java/tests/sql/ResultSetMetaDataTest.java
@@ -16,12 +16,18 @@
 
 package tests.sql;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 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;
@@ -54,6 +60,16 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getCatalogName(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "1. SQLException checking missed. " +
+                  "2. MAX/MIN/negative/valid parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getCatalogName",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetCatalogName() throws SQLException {
         try {
             assertNull(rsmd.getCatalogName(0));
@@ -65,6 +81,16 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnClassName(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "1. SQLException checking missed. " +
+                "2. MAX/MIN/zero parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnClassName",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetColumnClassName() {
         try {
             assertNotNull(rsmd);
@@ -93,6 +119,15 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnCount()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnCount",
+          methodArgs = {}
+        )
+    })
     public void testGetColumnCount() {
         try {
             assertEquals(3, rsmd.getColumnCount());
@@ -104,6 +139,16 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnLabel(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "1. SQLException checking missed. " +
+                "2. MAX/MIN/negative/zero parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnLabel",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetColumnLabel() {
         String[] labels = { "zoo.id", "zoo.name", "zoo.family" };
         try {
@@ -119,6 +164,15 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnName(int column)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "getColumnLable was tested instead of getColumnName",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnName",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetColumnName() {
         String[] labels = { "zoo.id", "zoo.name", "zoo.family" };
         try {
@@ -148,6 +202,15 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnType(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "MAX/MIN/zero parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnType",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetColumnType() {
         int[] types = { Types.SMALLINT, Types.VARCHAR, Types.VARCHAR};
         try {
@@ -176,6 +239,15 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getColumnTypeName(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "MAX/MIN/zero parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getColumnTypeName",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetColumnTypeName() {
         try {
             assertEquals("smallint", rsmd.getColumnTypeName(1));
@@ -202,6 +274,15 @@ public class ResultSetMetaDataTest extends SQLTest {
     /**
      * @test java.sql.ResultSetMetaData#getTableName(int column)
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "MAX/MIN/zero parameters checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getTableName",
+          methodArgs = {int.class}
+        )
+    })
     public void testGetTableName() {
         try {
             assertEquals("zoo", rsmd.getTableName(1));
diff --git a/sql/src/test/java/tests/sql/SQLTest.java b/sql/src/test/java/tests/sql/SQLTest.java
index 08ae350..4bc4af6 100755
--- a/sql/src/test/java/tests/sql/SQLTest.java
+++ b/sql/src/test/java/tests/sql/SQLTest.java
@@ -16,6 +16,8 @@
 
 package tests.sql;
 
+import dalvik.annotation.TestTargetClass;
+
 import java.io.File;
 import java.sql.Connection;
 import java.sql.DriverManager;
@@ -30,6 +32,7 @@ import junit.framework.Test;
 import junit.framework.TestCase;
 import junit.framework.TestSuite;
 
+@TestTargetClass(Statement.class)
 public class SQLTest extends TestCase {
     static Connection conn;
 
diff --git a/sql/src/test/java/tests/sql/StatementTest.java b/sql/src/test/java/tests/sql/StatementTest.java
index fd1002e..54561fa 100755
--- a/sql/src/test/java/tests/sql/StatementTest.java
+++ b/sql/src/test/java/tests/sql/StatementTest.java
@@ -14,7 +14,12 @@
  * limitations under the License.
  */
 
-package tests.sql;
+package tests.sql;     
+
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
 
 import java.sql.BatchUpdateException;
 import java.sql.ResultSet;
@@ -23,11 +28,21 @@ import java.sql.SQLWarning;
 import java.sql.Statement;
 import java.util.Vector;
 
+@TestTargetClass(Statement.class)
 public class StatementTest extends SQLTest {
     
     /**
      * @test java.sql.Statement#addBatch(String)
      */
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "addBatch",
+          methodArgs = {String.class}
+        )
+    })
     public void testAddBatch() throws SQLException {
         
         Statement st = null;
@@ -81,6 +96,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#clearWarnings()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "clearWarnings",
+          methodArgs = {}
+        )
+    })
     public void testClearWarnings() {
         Statement st = null;
         try {
@@ -159,6 +183,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#clearBatch(String)
      */
+    @TestInfo(
+      level = TestLevel.TODO,
+      purpose = "addBatch tested instead of clearBatch method",
+      targets = {
+        @TestTarget(
+          methodName = "clearBatch",
+          methodArgs = {}
+        )
+    })
     public void testClearBatch() throws SQLException {
         
         Statement st = null;
@@ -216,6 +249,15 @@ public class StatementTest extends SQLTest {
      * TODO not pass on SQLite and RI.
      * 
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "execute",
+          methodArgs = {String.class}
+        )
+    })
     public void testExecute() throws SQLException {
 
         String[] queries = {
@@ -306,6 +348,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#getConnection()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getConnection",
+          methodArgs = {}
+        )
+    })
     public void testGetConnection() {
         Statement st = null;
         try {
@@ -324,6 +375,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#getFetchDirection()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getFetchDirection",
+          methodArgs = {}
+        )
+    })
     public void testGetFetchDirection() {
         Statement st = null;
         try {
@@ -387,6 +447,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#getFetchSize()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getFetchSize",
+          methodArgs = {}
+        )
+    })
     public void testGetFetchSize() {
         Statement st = null;
         try {
@@ -560,7 +629,16 @@ public class StatementTest extends SQLTest {
      * @test java.sql.Statement#close()
      * TODO not passed but according to Java Docs
      */
-    public void testClose() {
+    @TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "close",
+          methodArgs = {}
+        )
+    })
+    public void _testClose() {
         Statement st = null;
         try {
             String[] queries = {
@@ -657,6 +735,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#executeBatch()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException, BatchUpdateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "executeBatch",
+          methodArgs = {}
+        )
+    })
     public void testExecuteBatch() {
 
         String[] queries = {
@@ -706,7 +793,16 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#executeQuery(String sql)
      */
-    public void testExecuteQuery_String() {
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Null/empty parameter checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "executeQuery",
+          methodArgs = {String.class}
+        )
+    })
+    public void _testExecuteQuery_String() {
 
         String[] queries1 = { "select * from zoo",
                 "select name, family from zoo where id = 1" };
@@ -765,7 +861,16 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#executeUpdate(String sql)
      */
-    public void testExecuteUpdate_String() {
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Null/empty parameter checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "executeUpdate",
+          methodArgs = {String.class}
+        )
+    })
+    public void _testExecuteUpdate_String() {
 
         String[] queries1 = {
                 "update zoo set name='Masha', family='cat' where id=2;",
@@ -932,6 +1037,15 @@ public class StatementTest extends SQLTest {
     /**
      * @test java.sql.Statement#getUpdateCount()
      */
+    @TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SQLException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "getUpdateCount",
+          methodArgs = {}
+        )
+    })
     public void testGetUpdateCount() {
         Statement st = null;
         try {