auto import from //branches/cupcake/...@125939

109 files changed, 11669 insertions, 10403 deletions

diff --git a/nio/src/main/java/java/nio/Buffer.java b/nio/src/main/java/java/nio/Buffer.java
index 9e870e4..844d2ce 100644
--- a/nio/src/main/java/java/nio/Buffer.java
+++ b/nio/src/main/java/java/nio/Buffer.java
@@ -150,11 +150,21 @@ public abstract class Buffer {
      * @since Android 1.0
      */
     public final Buffer clear() {
+        // BEGIN android-changed
+        internalClear();
+        // END android-changed
+        return this;
+    }
+
+    // BEGIN android-added
+    // We need a possibility to change the behavior of clear in some optimized
+    // DirectByteBuffer adapters.
+    void internalClear() {
         position = 0;
         mark = UNSET_MARK;
         limit = capacity;
-        return this;
     }
+    // END android-added
 
     /**
      * Flips this buffer.
diff --git a/nio/src/main/java/java/nio/IntToByteBufferAdapter.java b/nio/src/main/java/java/nio/IntToByteBufferAdapter.java
index b5e1118..e52f6b6 100644
--- a/nio/src/main/java/java/nio/IntToByteBufferAdapter.java
+++ b/nio/src/main/java/java/nio/IntToByteBufferAdapter.java
@@ -203,6 +203,14 @@ final class IntToByteBufferAdapter extends IntBuffer implements DirectBuffer {
             return super.put(i, off, len);
         }
     }
+    
+    @Override
+    void internalClear() {
+        if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
+            byteBuffer.clear();
+        }
+        super.internalClear();
+    }
     // END android-added
 
     public IntBuffer slice() {
diff --git a/nio/src/main/java/java/nio/ShortToByteBufferAdapter.java b/nio/src/main/java/java/nio/ShortToByteBufferAdapter.java
index a3c3e38..fe4fff4 100644
--- a/nio/src/main/java/java/nio/ShortToByteBufferAdapter.java
+++ b/nio/src/main/java/java/nio/ShortToByteBufferAdapter.java
@@ -203,6 +203,14 @@ final class ShortToByteBufferAdapter extends ShortBuffer implements DirectBuffer
             return super.put(s, off, len);
         }
     }
+    
+    @Override
+    void internalClear() {
+        if (byteBuffer instanceof ReadWriteDirectByteBuffer) {
+            byteBuffer.clear();
+        }
+        super.internalClear();
+    }
     // END android-added
 
     public ShortBuffer slice() {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AbstractBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AbstractBufferTest.java
index f58bf7d..901a2a6 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AbstractBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AbstractBufferTest.java
@@ -16,9 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.Buffer;
@@ -26,45 +25,44 @@ import java.nio.ByteBuffer;
 import java.nio.InvalidMarkException;
 
 import junit.framework.TestCase;
-@TestTargetClass(java.nio.Buffer.class)
+
 /**
  * Tests a java.nio.Buffer instance.
  */
+@TestTargetClass(java.nio.Buffer.class)
 public class AbstractBufferTest extends TestCase {
     
     protected Buffer baseBuf;
+    protected int capacity;
     
     protected void setUp() throws Exception{
         super.setUp();
+        capacity = 10;
         baseBuf = ByteBuffer.allocate(10);
     }
     
     protected void tearDown() throws Exception{
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check capacity with which the buffer is created.",
-      targets = {
-        @TestTarget(
-          methodName = "capacity",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "capacity",
+        args = {}
+    )
     public void testCapacity() {
         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
                 && baseBuf.limit() <= baseBuf.capacity());
+        assertEquals(capacity, baseBuf.capacity());
     }
-    @TestInfo(
-          level = TestLevel.COMPLETE,
-          // level = TestLevel.PARTIAL
-          purpose = "",
-          targets = {
-            @TestTarget(
-              methodName = "clear",
-              methodArgs = {}
-            )
-        })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "clear",
+        args = {}
+    )
     public void testClear() {
         // save state
         int oldPosition = baseBuf.position();
@@ -72,7 +70,7 @@ public class AbstractBufferTest extends TestCase {
 
         Buffer ret = baseBuf.clear();
         assertSame(ret, baseBuf);
-        assertEquals(baseBuf.position(), 0);
+        assertEquals(0, baseBuf.position());
         assertEquals(baseBuf.limit(), baseBuf.capacity());
         try {
             baseBuf.reset();
@@ -85,24 +83,24 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check that mark is discarted.",
-      targets = {
-        @TestTarget(
-          methodName = "flip",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "flip",
+        args = {}
+    )
     public void testFlip() {
         // save state
         int oldPosition = baseBuf.position();
         int oldLimit = baseBuf.limit();
 
+        baseBuf.mark();
+
         Buffer ret = baseBuf.flip();
         assertSame(ret, baseBuf);
-        assertEquals(baseBuf.position(), 0);
-        assertEquals(baseBuf.limit(), oldPosition);
+        assertEquals(0, baseBuf.position());
+        assertEquals(oldPosition, baseBuf.limit());
         try {
             baseBuf.reset();
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -114,15 +112,13 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hasRemaining",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasRemaining",
+        args = {}
+    )
     public void testHasRemaining() {
         // save state
         int oldPosition = baseBuf.position();
@@ -136,15 +132,13 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Abstract method.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Abstract method.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         baseBuf.isReadOnly();
     }
@@ -152,32 +146,27 @@ public class AbstractBufferTest extends TestCase {
     /*
      * Class under test for int limit()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "limit",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "limit",
+        args = {}
+    )
     public void testLimit() {
         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
                 && baseBuf.limit() <= baseBuf.capacity());
+        assertEquals(capacity, baseBuf.limit());
     }
 
     /*
      * Class under test for Buffer limit(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "limit",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "limit",
+        args = {int.class}
+    )
     public void testLimitint() {
         // save state
         int oldPosition = baseBuf.position();
@@ -190,24 +179,23 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(baseBuf.capacity());
         assertEquals(baseBuf.limit(), baseBuf.capacity());
         // position should not change
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
         // mark should be valid
         baseBuf.reset();
 
-        if (baseBuf.capacity() > 0) {
-            baseBuf.limit(baseBuf.capacity());
-            baseBuf.position(baseBuf.capacity());
-            baseBuf.mark();
-            baseBuf.limit(baseBuf.capacity() - 1);
-            // position should be the new limit
-            assertEquals(baseBuf.position(), baseBuf.limit());
-            // mark should be invalid
-            try {
-                baseBuf.reset();
-                fail("Should throw Exception"); //$NON-NLS-1$
-            } catch (InvalidMarkException e) {
-                // expected
-            }
+        assertTrue("The buffer capacity was 0", baseBuf.capacity() > 0);
+        baseBuf.limit(baseBuf.capacity());
+        baseBuf.position(baseBuf.capacity());
+        baseBuf.mark();
+        baseBuf.limit(baseBuf.capacity() - 1);
+        // position should be the new limit
+        assertEquals(baseBuf.limit(), baseBuf.position());
+        // mark should be invalid
+        try {
+            baseBuf.reset();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (InvalidMarkException e) {
+            // expected
         }
 
         try {
@@ -227,15 +215,13 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "mark",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "mark",
+        args = {}
+    )
     public void testMark() {
         // save state
         int oldPosition = baseBuf.position();
@@ -247,12 +233,12 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.mark();
         baseBuf.position(baseBuf.limit());
         baseBuf.reset();
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
 
         baseBuf.mark();
         baseBuf.position(baseBuf.limit());
         baseBuf.reset();
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
 
         // restore state
         baseBuf.limit(oldLimit);
@@ -262,32 +248,27 @@ public class AbstractBufferTest extends TestCase {
     /*
      * Class under test for int position()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void testPosition() {
         assertTrue(0 <= baseBuf.position() && baseBuf.position() <= baseBuf.limit()
                 && baseBuf.limit() <= baseBuf.capacity());
+        assertEquals(0, baseBuf.position());
     }
 
     /*
      * Class under test for Buffer position(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {int.class}
+    )
     public void testPositionint() {
         // save state
         int oldPosition = baseBuf.position();
@@ -309,26 +290,25 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.mark();
         baseBuf.position(baseBuf.position());
         baseBuf.reset();
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
 
         baseBuf.position(0);
-        assertEquals(baseBuf.position(), 0);
+        assertEquals(0, baseBuf.position());
+        baseBuf.position(baseBuf.limit());
+        assertEquals(baseBuf.limit(), baseBuf.position());
+
+        assertTrue("The buffer capacity was 0.", baseBuf.capacity() > 0);
+        baseBuf.limit(baseBuf.capacity());
         baseBuf.position(baseBuf.limit());
-        assertEquals(baseBuf.position(), baseBuf.limit());
-
-        if (baseBuf.capacity() > 0) {
-            baseBuf.limit(baseBuf.capacity());
-            baseBuf.position(baseBuf.limit());
-            baseBuf.mark();
-            baseBuf.position(baseBuf.limit() - 1);
-            assertEquals(baseBuf.position(), baseBuf.limit() - 1);
-            // mark should be invalid
-            try {
-                baseBuf.reset();
-                fail("Should throw Exception"); //$NON-NLS-1$
-            } catch (InvalidMarkException e) {
-                // expected
-            }
+        baseBuf.mark();
+        baseBuf.position(baseBuf.limit() - 1);
+        assertEquals(baseBuf.limit() - 1, baseBuf.position());
+        // mark should be invalid
+        try {
+            baseBuf.reset();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (InvalidMarkException e) {
+            // expected
         }
 
         Buffer ret = baseBuf.position(0);
@@ -338,27 +318,23 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "remaining",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "remaining",
+        args = {}
+    )
     public void testRemaining() {
         assertEquals(baseBuf.remaining(), baseBuf.limit() - baseBuf.position());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "reset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "reset",
+        args = {}
+    )
     public void testReset() {
         // save state
         int oldPosition = baseBuf.position();
@@ -367,12 +343,12 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.mark();
         baseBuf.position(baseBuf.limit());
         baseBuf.reset();
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
 
         baseBuf.mark();
         baseBuf.position(baseBuf.limit());
         baseBuf.reset();
-        assertEquals(baseBuf.position(), oldPosition);
+        assertEquals(oldPosition, baseBuf.position());
 
         Buffer ret = baseBuf.reset();
         assertSame(ret, baseBuf);
@@ -389,22 +365,20 @@ public class AbstractBufferTest extends TestCase {
         baseBuf.limit(oldLimit);
         baseBuf.position(oldPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "rewind",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "rewind",
+        args = {}
+    )
     public void testRewind() {
         // save state
         int oldPosition = baseBuf.position();
         int oldLimit = baseBuf.limit();
 
         Buffer ret = baseBuf.rewind();
-        assertEquals(baseBuf.position(), 0);
+        assertEquals(0, baseBuf.position());
         assertSame(ret, baseBuf);
         try {
             baseBuf.reset();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AllTests.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AllTests.java
index 5b4cbc5..6528c22 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AllTests.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/AllTests.java
@@ -31,7 +31,7 @@ public class AllTests {
     }
 
     public static Test suite() {
-        TestSuite suite = new TestSuite("Tests for java.nio");
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("Tests for java.nio");
         //$JUnit-BEGIN$
         suite.addTestSuite(ReadOnlyHeapShortBufferTest.class);
         suite.addTestSuite(ReadOnlyLongBufferTest.class);
@@ -70,7 +70,6 @@ public class AllTests {
         suite.addTestSuite(DoubleBufferTest.class);
         suite.addTestSuite(ReadOnlyWrappedFloatBufferTest.class);
         suite.addTestSuite(ShortBufferTest.class);
-        suite.addTestSuite(BufferTest.class);
         suite.addTestSuite(DirectFloatBufferTest.class);
         suite.addTestSuite(SliceWrappedByteBufferTest.class);
         suite.addTestSuite(DirectCharBufferTest.class);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferOverflowExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferOverflowExceptionTest.java
index 7d8c763..d7dd36e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferOverflowExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferOverflowExceptionTest.java
@@ -16,9 +16,9 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -33,15 +33,20 @@ public class BufferOverflowExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility. And tests default constructor",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "BufferOverflowException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new BufferOverflowException());
@@ -50,17 +55,41 @@ public class BufferOverflowExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })   
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "BufferOverflowException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new BufferOverflowException());
     }
+
+    // BEGIN android-added
+    // copied from newer version of harmony
+    /**
+     *@tests {@link java.nio.BufferOverflowException#BufferOverflowException()}
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "BufferOverflowException",
+        args = {}
+    )
+    public void test_Constructor() {
+        BufferOverflowException exception = new BufferOverflowException();
+        assertNull(exception.getMessage());
+        assertNull(exception.getLocalizedMessage());
+        assertNull(exception.getCause());
+    }
+    // END android-added
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferTest.java
deleted file mode 100644
index a2ee5fd..0000000
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferTest.java
+++ /dev/null
@@ -1,458 +0,0 @@
-/*
- *  Licensed to the Apache Software Foundation (ASF) under one or more
- *  contributor license agreements.  See the NOTICE file distributed with
- *  this work for additional information regarding copyright ownership.
- *  The ASF licenses this file to You under the Apache License, Version 2.0
- *  (the "License"); you may not use this file except in compliance with
- *  the License.  You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- */
-
-package org.apache.harmony.nio.tests.java.nio;
-
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestTargetClass;
-
-import java.nio.Buffer;
-import java.nio.InvalidMarkException;
-
-import junit.framework.TestCase;
-/**
- * Test a java.nio.Buffer instance.
- */
-@TestTargetClass(Buffer.class)
-public class BufferTest extends TestCase {
-    @TestInfo(
-          level = TestLevel.PARTIAL,
-          purpose = "Verifies that buffer's state doesn't change after testing.",
-          targets = {
-            @TestTarget(
-              methodName = "position",
-              methodArgs = {}
-            ),
-            @TestTarget(
-              methodName = "limit",
-              methodArgs = {}
-            )
-        })
-    public static void testBufferInstance(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        testCapacity(buf);
-        testClear(buf);
-        testFlip(buf);
-        testHasRemaining(buf);
-        testIsReadOnly(buf);
-        testLimit(buf);
-        testLimitint(buf);
-        testMark(buf);
-        testPosition(buf);
-        testPositionint(buf);
-        testRemaining(buf);
-        testReset(buf);
-        testRewind(buf);
-        
-        // check state, should not change
-        assertEquals(buf.position(), oldPosition);
-        assertEquals(buf.limit(), oldLimit);
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check capacity with which the buffer is created.",
-      targets = {
-        @TestTarget(
-          methodName = "capacity",
-          methodArgs = {}
-        )
-    })
-    public static void testCapacity(Buffer buf) {
-        assertTrue(0 <= buf.position() && buf.position() <= buf.limit()
-                && buf.limit() <= buf.capacity());
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "clear",
-          methodArgs = {}
-        )
-    })
-    public static void testClear(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        Buffer ret = buf.clear();
-        assertSame(ret, buf);
-        assertEquals(buf.position(), 0);
-        assertEquals(buf.limit(), buf.capacity());
-        try {
-            buf.reset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (InvalidMarkException e) {
-            // expected
-        }
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check that mark is discarded after a call of flip " +
-            "method. ",
-      targets = {
-        @TestTarget(
-          methodName = "flip",
-          methodArgs = {}
-        )
-    })
-    public static void testFlip(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        Buffer ret = buf.flip();
-        assertSame(ret, buf);
-        assertEquals(buf.position(), 0);
-        assertEquals(buf.limit(), oldPosition);
-        try {
-            buf.reset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (InvalidMarkException e) {
-            // expected
-        }
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hasRemaining",
-          methodArgs = {}
-        )
-    })
-    public static void testHasRemaining(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        assertEquals(buf.hasRemaining(), buf.position() < buf.limit());
-        buf.position(buf.limit());
-        assertFalse(buf.hasRemaining());
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Abstract method.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
-    public static void testIsReadOnly(Buffer buf) {
-        buf.isReadOnly();
-    }
-
-    /*
-     * Class under test for int limit()
-     */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "limit",
-          methodArgs = {}
-        )
-    })
-    public static void testLimit(Buffer buf) {
-        assertTrue(0 <= buf.position() && buf.position() <= buf.limit()
-                && buf.limit() <= buf.capacity());
-    }
-
-    /*
-     * Class under test for Buffer limit(int)
-     */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "limit",
-          methodArgs = {int.class}
-        )
-    })
-    public static void testLimitint(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-        
-        Buffer ret = buf.limit(buf.limit());
-        assertSame(ret, buf);
-
-        buf.mark();
-        buf.limit(buf.capacity());
-        assertEquals(buf.limit(), buf.capacity());
-        // position should not change
-        assertEquals(buf.position(), oldPosition);
-        // mark should be valid
-        buf.reset();
-
-        if (buf.capacity() > 0) {
-            buf.limit(buf.capacity());
-            buf.position(buf.capacity());
-            buf.mark();
-            buf.limit(buf.capacity() - 1);
-            // position should be the new limit
-            assertEquals(buf.position(), buf.limit());
-            // mark should be invalid
-            try {
-                buf.reset();
-                fail("Should throw Exception"); //$NON-NLS-1$
-            } catch (InvalidMarkException e) {
-                // expected
-            }
-        }
-        
-        try {
-            buf.limit(-1);
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (IllegalArgumentException e) {
-            // expected
-        }
-        try {
-            buf.limit(buf.capacity() + 1);
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (IllegalArgumentException e) {
-            // expected
-        }
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "mark",
-          methodArgs = {}
-        )
-    })
-    public static void testMark(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        Buffer ret = buf.mark();
-        assertSame(ret, buf);
-
-        buf.mark();
-        buf.position(buf.limit());
-        buf.reset();
-        assertEquals(buf.position(), oldPosition);
-
-        buf.mark();
-        buf.position(buf.limit());
-        buf.reset();
-        assertEquals(buf.position(), oldPosition);
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-
-    /*
-     * Class under test for int position()
-     */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {}
-        )
-    })
-    public static void testPosition(Buffer buf) {
-        assertTrue(0 <= buf.position() && buf.position() <= buf.limit()
-                && buf.limit() <= buf.capacity());
-    }
-
-    /*
-     * Class under test for Buffer position(int)
-     */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {int.class}
-        )
-    })
-    public static void testPositionint(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-        
-        try {
-            buf.position(-1);
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (IllegalArgumentException e) {
-            // expected
-        }
-        try {
-            buf.position(buf.limit() + 1);
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (IllegalArgumentException e) {
-            // expected
-        }
-        
-        buf.mark();
-        buf.position(buf.position());
-        buf.reset();
-        assertEquals(buf.position(), oldPosition);
-        
-        buf.position(0);
-        assertEquals(buf.position(), 0);
-        buf.position(buf.limit());
-        assertEquals(buf.position(), buf.limit());
-        
-        if (buf.capacity() > 0) {
-            buf.limit(buf.capacity());
-            buf.position(buf.limit());
-            buf.mark();
-            buf.position(buf.limit() - 1);
-            assertEquals(buf.position(), buf.limit() - 1);
-            // mark should be invalid
-            try {
-                buf.reset();
-                fail("Should throw Exception"); //$NON-NLS-1$
-            } catch (InvalidMarkException e) {
-                // expected
-            }
-        }
-        
-        Buffer ret = buf.position(0);
-        assertSame(ret, buf);
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "remaining",
-          methodArgs = {}
-        )
-    })
-    public static void testRemaining(Buffer buf) {
-        assertEquals(buf.remaining(), buf.limit() - buf.position());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "reset",
-          methodArgs = {}
-        )
-    })
-    public static void testReset(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-
-        buf.mark();
-        buf.position(buf.limit());
-        buf.reset();
-        assertEquals(buf.position(), oldPosition);
-
-        buf.mark();
-        buf.position(buf.limit());
-        buf.reset();
-        assertEquals(buf.position(), oldPosition);
-        
-        Buffer ret = buf.reset();
-        assertSame(ret, buf);
-
-        buf.clear();
-        try {
-            buf.reset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (InvalidMarkException e) {
-            // expected
-        }
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "rewind",
-          methodArgs = {}
-        )
-    })
-    public static void testRewind(Buffer buf) {
-        // save state
-        int oldPosition = buf.position();
-        int oldLimit = buf.limit();
-        
-        Buffer ret = buf.rewind();
-        assertEquals(buf.position(), 0);
-        assertSame(ret, buf);
-        try {
-            buf.reset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (InvalidMarkException e) {
-            // expected
-        }
-
-        // restore state
-        buf.limit(oldLimit);
-        buf.position(oldPosition);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Doesn't test anything. Just to remove JUnit warning.",
-      targets = {
-        @TestTarget(
-          methodName = "",
-          methodArgs = {}
-        )
-    })
-    public void testNothing() {
-        // to remove JUnit warning
-    }
-    
-}
\ No newline at end of file
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferUnderflowExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferUnderflowExceptionTest.java
index 5180f52..2c8d09e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferUnderflowExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/BufferUnderflowExceptionTest.java
@@ -16,9 +16,9 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferUnderflowException;
@@ -27,24 +27,29 @@ import junit.framework.TestCase;
 
 import org.apache.harmony.testframework.serialization.SerializationTest;
 
-@TestTargetClass(BufferUnderflowException.class)
 /**
  * Tests for BufferUnderflowException
  */
+@TestTargetClass(BufferUnderflowException.class)
 public class BufferUnderflowExceptionTest extends TestCase {
 
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "BufferUnderflowException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new BufferUnderflowException());
@@ -53,17 +58,41 @@ public class BufferUnderflowExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "BufferUnderflowException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new BufferUnderflowException());
     }
+
+    // BEGIN android-added
+    // copied from newer version of harmony
+    /**
+     *@tests {@link java.nio.BufferUnderflowException#BufferUnderflowException()}
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "BufferUnderflowException",
+        args = {}
+    )
+    public void test_Constructor() {
+        BufferUnderflowException exception = new BufferUnderflowException();
+        assertNull(exception.getMessage());
+        assertNull(exception.getLocalizedMessage());
+        assertNull(exception.getCause());
+    }
+    // END android-added
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteBufferTest.java
index f97ad5f..8bf0208 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteBufferTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -48,6 +47,7 @@ public class ByteBufferTest extends AbstractBufferTest {
     protected ByteBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = 10;
         buf = ByteBuffer.allocate(10);
         baseBuf = buf;
     }
@@ -62,24 +62,30 @@ public class ByteBufferTest extends AbstractBufferTest {
      * 1. case for check ByteBuffer testBuf properties
      * 2. case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check backing array. Doesn't check boundary value " +
-            "of capacity.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
-        //    case: ByteBuffer testBuf properties is satisfy the conditions specification
+        // case: ByteBuffer testBuf properties is satisfy the conditions
+        // specification
         ByteBuffer testBuf = ByteBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
 
-        //    case: expected IllegalArgumentException
+        testBuf = ByteBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
+
+        // case: expected IllegalArgumentException
         try {
             testBuf = ByteBuffer.allocate(-20);
             fail("allocate method does not throws expected exception");
@@ -91,23 +97,40 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * test for method static ByteBuffer allocateDirect(int capacity)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check check backing array. Doesn't check boundary " +
-            "value of capacity.",
-      targets = {
-        @TestTarget(
-          methodName = "allocateDirect",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocateDirect",
+        args = {int.class}
+    )
     public void test_AllocateDirectI() {
-        //        case: ByteBuffer testBuf properties is satisfy the conditions specification
+        // case: ByteBuffer testBuf properties is satisfy the conditions
+        // specification
         ByteBuffer testBuf = ByteBuffer.allocateDirect(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
+        assertEquals(0, testBuf.position());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = ByteBuffer.allocateDirect(0);
+        assertEquals(0, testBuf.position());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
+        
+        try {
+            testBuf.array();
+            fail("Didn't throw expected UnsupportedOperationException.");
+        } catch (UnsupportedOperationException e) {
+            //expected
+        }
 
-        //    case: expected IllegalArgumentException
+        try {
+            testBuf.arrayOffset();
+            fail("Didn't throw expected UnsupportedOperationException.");
+        } catch (UnsupportedOperationException e) {
+            //expected
+        }
+
+        // case: expected IllegalArgumentException
         try {
             testBuf = ByteBuffer.allocate(-20);
             fail("allocate method does not throws expected exception");
@@ -115,107 +138,59 @@ public class ByteBufferTest extends AbstractBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The second if/else verifies the same case.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
-        if (buf.hasArray()) {
-            byte array[] = buf.array();
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        byte array[] = buf.array();
+        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
 
-            loadTestData1(array, buf.arrayOffset(), buf.capacity());
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData1(array, buf.arrayOffset(), buf.capacity());
+        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
 
-            loadTestData2(array, buf.arrayOffset(), buf.capacity());
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, buf.arrayOffset(), buf.capacity());
+        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
 
-            loadTestData1(buf);
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData1(buf);
+        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
 
-            loadTestData2(buf);
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-        } else {
-            if (buf.isReadOnly()) {
-                try {
-                    buf.array();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                    // Note:can not tell when to throw 
-                    // UnsupportedOperationException
-                    // or ReadOnlyBufferException, so catch all.
-                }
-            } else {
-                try {
-                    buf.array();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                }
-            }
-        }
+        loadTestData2(buf);
+        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The second if/else verifies the same case.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
-    public void testArrayOffset() {
-        if (buf.hasArray()) {
-            byte array[] = buf.array();
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-            loadTestData1(array, buf.arrayOffset(), buf.capacity());
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
 
-            loadTestData2(array, buf.arrayOffset(), buf.capacity());
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
+    public void testArrayOffset() {
+        byte array[] = buf.array();
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = (byte) i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-            loadTestData1(buf);
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        ByteBuffer wrapped = ByteBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-            loadTestData2(buf);
-            assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-        } else {
-            if (buf.isReadOnly()) {
-                try {
-                    buf.arrayOffset();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                    // Note:can not tell when to throw 
-                    // UnsupportedOperationException
-                    // or ReadOnlyBufferException, so catch all.
-                }
-            } else {
-                try {
-                    buf.arrayOffset();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                }
-            }
-        }
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -233,21 +208,19 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         // readonly's position, mark, and limit should be independent to buf
         readonly.reset();
-        assertEquals(readonly.position(), 0);
+        assertEquals(0, readonly.position());
         readonly.clear();
         assertEquals(buf.position(), buf.limit());
         buf.reset();
-        assertEquals(buf.position(), 0);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+        assertEquals(0, buf.position());
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         if (buf.isReadOnly()) {
             try {
@@ -265,8 +238,8 @@ public class ByteBufferTest extends AbstractBufferTest {
         loadTestData1(buf);
         ByteBuffer ret = buf.compact();
         assertSame(ret, buf);
-        assertEquals(buf.position(), buf.capacity());
-        assertEquals(buf.limit(), buf.capacity());
+        assertEquals(buf.capacity(), buf.position());
+        assertEquals(buf.capacity(), buf.limit());
         assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
         try {
             buf.reset();
@@ -281,7 +254,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.mark();
         ret = buf.compact();
         assertSame(ret, buf);
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
         assertEquals(buf.limit(), buf.capacity());
         assertContentLikeTestData1(buf, 0, (byte) 0, buf.capacity());
         try {
@@ -298,7 +271,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.mark();
         ret = buf.compact();
         assertSame(ret, buf);
-        assertEquals(buf.position(), 4);
+        assertEquals(4, buf.position());
         assertEquals(buf.limit(), buf.capacity());
         assertContentLikeTestData1(buf, 0, (byte) 1, 4);
         try {
@@ -308,15 +281,13 @@ public class ByteBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testCompareTo() {
         // compare to self
         assertEquals(0, buf.compareTo(buf));
@@ -344,15 +315,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         
         assertTrue(ByteBuffer.wrap(new byte[21]).compareTo(ByteBuffer.allocateDirect(21)) == 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -370,11 +339,11 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         // duplicate's position, mark, and limit should be independent to buf
         duplicate.reset();
-        assertEquals(duplicate.position(), 0);
+        assertEquals(0, duplicate.position());
         duplicate.clear();
         assertEquals(buf.position(), buf.limit());
         buf.reset();
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
 
         // duplicate share the same content with buf
         if (!duplicate.isReadOnly()) {
@@ -384,15 +353,13 @@ public class ByteBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -418,19 +385,16 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for byte get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), i);
+            assertEquals(i, buf.position());
             assertEquals(buf.get(), buf.get(i));
         }
         try {
@@ -444,30 +408,31 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer get(byte[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {byte[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {byte[].class}
+    )
     public void testGetbyteArray() {
         byte array[] = new byte[1];
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), i);
+            assertEquals(i, buf.position());
             ByteBuffer ret = buf.get(array);
             assertEquals(array[0], buf.get(i));
             assertSame(ret, buf);
         }
+
+        buf.get(new byte[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
         try {
             buf.get((byte[])null);
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -479,15 +444,12 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer get(byte[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {byte[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {byte[].class, int.class, int.class}
+    )
     public void testGetbyteArrayintint() {
         buf.clear();
         byte array[] = new byte[buf.capacity()];
@@ -498,7 +460,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (BufferUnderflowException e) {
             // expected
         }
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
         try {
             buf.get(array, -1, array.length);
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -512,7 +474,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
         try {
             buf.get(array, 2, -1);
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -543,7 +505,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
 
         buf.clear();
         ByteBuffer ret = buf.get(array, 0, array.length);
@@ -555,19 +517,16 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for byte get(int)
      */
-    @TestInfo(
-          level = TestLevel.COMPLETE,
-          purpose = "",
-          targets = {
-            @TestTarget(
-              methodName = "get",
-              methodArgs = {int.class}
-            )
-        })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), i);
+            assertEquals(i, buf.position());
             assertEquals(buf.get(), buf.get(i));
         }
         try {
@@ -583,48 +542,35 @@ public class ByteBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same verification in if/else block.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         if (buf.hasArray()) {
             assertNotNull(buf.array());
         } else {
-            if (buf.isReadOnly()) {
-                try {
-                    buf.array();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                    // Note:can not tell when to throw 
-                    // UnsupportedOperationException
-                    // or ReadOnlyBufferException, so catch all.
-                }
-            } else {
-                try {
-                    buf.array();
-                    fail("Should throw Exception"); //$NON-NLS-1$
-                } catch (UnsupportedOperationException e) {
-                    // expected
-                }
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
             }
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         loadTestData1(buf);
@@ -637,9 +583,14 @@ public class ByteBufferTest extends AbstractBufferTest {
     }
     
     //for the testHashCode() method of readonly subclasses
-    protected void readOnlyHashCode() {
-        //create a new buffer initiated with some data 
-        ByteBuffer buf = ByteBuffer.allocate(BUFFER_LENGTH);
+    protected void readOnlyHashCode(boolean direct) {
+        //create a new buffer initiated with some data
+        ByteBuffer buf;
+        if (direct) {
+            buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
+        } else {
+            buf = ByteBuffer.allocate(BUFFER_LENGTH);
+        }
         loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
         buf.clear();
@@ -649,27 +600,23 @@ public class ByteBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity()/2);
         assertTrue(buf.hashCode()!= duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Abstract method.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Abstract method.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         buf.isDirect();
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         // BIG_ENDIAN is the default byte order
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
@@ -692,15 +639,12 @@ public class ByteBufferTest extends AbstractBufferTest {
      * test covers following usecases:
      * 1. case for check
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {java.nio.ByteOrder.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {java.nio.ByteOrder.class}
+    )
     public void test_OrderLjava_lang_ByteOrder() {
         //         BIG_ENDIAN is the default byte order
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
@@ -721,15 +665,12 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer put(byte)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {byte.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "put",
+        args = {byte.class}
+    )
     public void testPutbyte() {
         if (buf.isReadOnly()) {
             try {
@@ -744,9 +685,9 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), i);
+            assertEquals(i, buf.position());
             ByteBuffer ret = buf.put((byte) i);
-            assertEquals(buf.get(i), (byte) i);
+            assertEquals((byte) i, buf.get(i));
             assertSame(ret, buf);
         }
         try {
@@ -755,20 +696,24 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (BufferOverflowException e) {
             // expected
         }
+
+        buf.rewind();
+        buf.put(Byte.MAX_VALUE);
+        assertEquals(Byte.MAX_VALUE, buf.get(0));
+        buf.rewind();
+        buf.put(Byte.MIN_VALUE);
+        assertEquals(Byte.MIN_VALUE, buf.get(0));
     }
 
     /*
      * Class under test for java.nio.ByteBuffer put(byte[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {byte[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "put",
+        args = {byte[].class}
+    )
     public void testPutbyteArray() {
         byte array[] = new byte[1];
         if (buf.isReadOnly()) {
@@ -783,10 +728,10 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), i);
+            assertEquals(i, buf.position());
             array[0] = (byte) i;
             ByteBuffer ret = buf.put(array);
-            assertEquals(buf.get(i), (byte) i);
+            assertEquals((byte) i, buf.get(i));
             assertSame(ret, buf);
         }
         try {
@@ -806,15 +751,12 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer put(byte[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {byte[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "put",
+        args = {byte[].class, int.class, int.class}
+    )
     public void testPutbyteArrayintint() {
         buf.clear();
         byte array[] = new byte[buf.capacity()];
@@ -834,7 +776,7 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (BufferOverflowException e) {
             // expected
         }
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
         try {
             buf.put(array, -1, array.length);
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -848,7 +790,7 @@ public class ByteBufferTest extends AbstractBufferTest {
             // expected
         }
         buf.put(array, array.length, 0);
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
         try {
             buf.put(array, 0, -1);
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -881,7 +823,7 @@ public class ByteBufferTest extends AbstractBufferTest {
             // expected
         }
         
-        assertEquals(buf.position(), 0);
+        assertEquals(0, buf.position());
 
         loadTestData2(array, 0, array.length);
         ByteBuffer ret = buf.put(array, 0, array.length);
@@ -893,15 +835,12 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer put(java.nio.ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "put",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testPutByteBuffer() {
         ByteBuffer other = ByteBuffer.allocate(buf.capacity());
         if (buf.isReadOnly()) {
@@ -954,15 +893,12 @@ public class ByteBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ByteBuffer put(int, byte)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, byte.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "put",
+        args = {int.class, byte.class}
+    )
     public void testPutintbyte() {
         if (buf.isReadOnly()) {
             try {
@@ -976,9 +912,9 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
-            assertEquals(buf.position(), 0);
+            assertEquals(0, buf.position());
             ByteBuffer ret = buf.put(i, (byte) i);
-            assertEquals(buf.get(i), (byte) i);
+            assertEquals((byte) i, buf.get(i));
             assertSame(ret, buf);
         }
         try {
@@ -993,16 +929,19 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
+
+        buf.put(0, Byte.MAX_VALUE);
+        assertEquals(Byte.MAX_VALUE, buf.get(0));
+        buf.put(0, Byte.MIN_VALUE);
+        assertEquals(Byte.MIN_VALUE, buf.get(0));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > SMALL_TEST_LENGTH);
         buf.position(1);
@@ -1012,9 +951,9 @@ public class ByteBufferTest extends AbstractBufferTest {
         assertEquals(buf.isReadOnly(), slice.isReadOnly());
         assertEquals(buf.isDirect(), slice.isDirect());
         assertEquals(buf.order(), slice.order());
-        assertEquals(slice.position(), 0);
-        assertEquals(slice.limit(), buf.remaining());
-        assertEquals(slice.capacity(), buf.remaining());
+        assertEquals(0, slice.position());
+        assertEquals(buf.remaining(), slice.limit());
+        assertEquals(buf.remaining(), slice.capacity());
         try {
             slice.reset();
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -1027,18 +966,16 @@ public class ByteBufferTest extends AbstractBufferTest {
             loadTestData1(slice);
             assertContentLikeTestData1(buf, 1, (byte) 0, slice.capacity());
             buf.put(2, (byte) 100);
-            assertEquals(slice.get(1), 100);
-        }
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+            assertEquals(100, slice.get(1));
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Byte") >= 0 || str.indexOf("byte") >= 0);
@@ -1046,15 +983,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         assertTrue(str.indexOf("" + buf.limit()) >= 0);
         assertTrue(str.indexOf("" + buf.capacity()) >= 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asCharBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asCharBuffer",
+        args = {}
+    )
     public void testAsCharBuffer() {
         CharBuffer charBuffer;
         byte bytes[] = new byte[2];
@@ -1110,15 +1045,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asDoubleBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asDoubleBuffer",
+        args = {}
+    )
     public void testAsDoubleBuffer() {
         DoubleBuffer doubleBuffer;
         byte bytes[] = new byte[8];
@@ -1181,15 +1114,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asFloatBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asFloatBuffer",
+        args = {}
+    )
     public void testAsFloatBuffer() {
         FloatBuffer floatBuffer;
         byte bytes[] = new byte[4];
@@ -1252,15 +1183,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asIntBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asIntBuffer",
+        args = {}
+    )
     public void testAsIntBuffer() {
         IntBuffer intBuffer;
         byte bytes[] = new byte[4];
@@ -1317,15 +1246,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asLongBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asLongBuffer",
+        args = {}
+    )
     public void testAsLongBuffer() {
         LongBuffer longBuffer;
         byte bytes[] = new byte[8];
@@ -1382,15 +1309,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asShortBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asShortBuffer",
+        args = {}
+    )
     public void testAsShortBuffer() {
         ShortBuffer shortBuffer;
         byte bytes[] = new byte[2];
@@ -1447,15 +1372,13 @@ public class ByteBufferTest extends AbstractBufferTest {
         buf.clear();
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getChar",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getChar",
+        args = {}
+    )
     public void testGetChar() {
         int nbytes = 2;
         byte bytes[] = new byte[nbytes];
@@ -1481,15 +1404,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getChar",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getChar",
+        args = {int.class}
+    )
     public void testGetCharint() {
         int nbytes = 2;
         byte bytes[] = new byte[nbytes];
@@ -1520,15 +1441,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "putChar",
-          methodArgs = {char.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putChar",
+        args = {char.class}
+    )
     public void testPutChar() {
         if (buf.isReadOnly()) {
             try {
@@ -1565,16 +1484,21 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.rewind();
+        buf.putChar(0, Character.MAX_VALUE);
+        assertEquals(Character.MAX_VALUE, buf.getChar(0));
+        buf.rewind();
+        buf.putChar(0, Character.MIN_VALUE);
+        assertEquals(Character.MIN_VALUE, buf.getChar(0));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "putChar",
-          methodArgs = {int.class, char.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putChar",
+        args = {int.class, char.class}
+    )
     public void testPutCharint() {
         if (buf.isReadOnly()) {
             try {
@@ -1621,16 +1545,19 @@ public class ByteBufferTest extends AbstractBufferTest {
         } catch (IndexOutOfBoundsException e) {
             //expected 
         }
+
+        buf.putChar(0, Character.MAX_VALUE);
+        assertEquals(Character.MAX_VALUE, buf.getChar(0));
+        buf.putChar(0, Character.MIN_VALUE);
+        assertEquals(Character.MIN_VALUE, buf.getChar(0));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getDouble",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getDouble",
+        args = {}
+    )
     public void testGetDouble() {
         int nbytes = 8;
         byte bytes[] = new byte[nbytes];
@@ -1659,15 +1586,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getDouble",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getDouble",
+        args = {int.class}
+    )
     public void testGetDoubleint() {
         int nbytes = 8;
         byte bytes[] = new byte[nbytes];
@@ -1707,15 +1632,13 @@ public class ByteBufferTest extends AbstractBufferTest {
             //expected 
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putDouble",
-          methodArgs = {double.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putDouble",
+        args = {double.class}
+    )
     public void testPutDouble() {
         if (buf.isReadOnly()) {
             try {
@@ -1752,16 +1675,30 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putDouble",
-          methodArgs = {int.class, double.class}
-        )
-    })
+
+        buf.rewind();
+        buf.putDouble(Double.MAX_VALUE);
+        assertEquals(Double.MAX_VALUE, buf.getDouble(0));
+        buf.rewind();
+        buf.putDouble(Double.MIN_VALUE);
+        assertEquals(Double.MIN_VALUE, buf.getDouble(0));
+        buf.rewind();
+        buf.putDouble(Double.NaN);
+        assertEquals(Double.NaN, buf.getDouble(0));
+        buf.rewind();
+        buf.putDouble(Double.NEGATIVE_INFINITY);
+        assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
+        buf.rewind();
+        buf.putDouble(Double.POSITIVE_INFINITY);
+        assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putDouble",
+        args = {int.class, double.class}
+    )
     public void testPutDoubleint() {
         if (buf.isReadOnly()) {
             try {
@@ -1802,16 +1739,25 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getFloat",
-          methodArgs = {}
-        )
-    })
+
+        buf.putDouble(0, Double.MAX_VALUE);
+        assertEquals(Double.MAX_VALUE, buf.getDouble(0));
+        buf.putDouble(0, Double.MIN_VALUE);
+        assertEquals(Double.MIN_VALUE, buf.getDouble(0));
+        buf.putDouble(0, Double.NaN);
+        assertEquals(Double.NaN, buf.getDouble(0));
+        buf.putDouble(0, Double.NEGATIVE_INFINITY);
+        assertEquals(Double.NEGATIVE_INFINITY, buf.getDouble(0));
+        buf.putDouble(0, Double.POSITIVE_INFINITY);
+        assertEquals(Double.POSITIVE_INFINITY, buf.getDouble(0));
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getFloat",
+        args = {}
+    )
     public void testGetFloat() {
         int nbytes = 4;
         byte bytes[] = new byte[nbytes];
@@ -1840,15 +1786,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getFloat",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getFloat",
+        args = {int.class}
+    )
     public void testGetFloatint() {
         int nbytes = 4;
         byte bytes[] = new byte[nbytes];
@@ -1882,15 +1826,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putFloat",
-          methodArgs = {float.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putFloat",
+        args = {float.class}
+    )
     public void testPutFloat() {
         if (buf.isReadOnly()) {
             try {
@@ -1927,16 +1869,30 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putFloat",
-          methodArgs = {int.class, float.class}
-        )
-    })
+
+        buf.rewind();
+        buf.putFloat(Float.MAX_VALUE);
+        assertEquals(Float.MAX_VALUE, buf.getFloat(0));
+        buf.rewind();
+        buf.putFloat(Float.MIN_VALUE);
+        assertEquals(Float.MIN_VALUE, buf.getFloat(0));
+        buf.rewind();
+        buf.putFloat(Float.NaN);
+        assertEquals(Float.NaN, buf.getFloat(0));
+        buf.rewind();
+        buf.putFloat(Float.NEGATIVE_INFINITY);
+        assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
+        buf.rewind();
+        buf.putFloat(Float.POSITIVE_INFINITY);
+        assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putFloat",
+        args = {int.class, float.class}
+    )
     public void testPutFloatint() {
         if (buf.isReadOnly()) {
             try {
@@ -1977,16 +1933,25 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getInt",
-          methodArgs = {}
-        )
-    })
+
+        buf.putFloat(0, Float.MAX_VALUE);
+        assertEquals(Float.MAX_VALUE, buf.getFloat(0));
+        buf.putFloat(0, Float.MIN_VALUE);
+        assertEquals(Float.MIN_VALUE, buf.getFloat(0));
+        buf.putFloat(0, Float.NaN);
+        assertEquals(Float.NaN, buf.getFloat(0));
+        buf.putFloat(0, Float.NEGATIVE_INFINITY);
+        assertEquals(Float.NEGATIVE_INFINITY, buf.getFloat(0));
+        buf.putFloat(0, Float.POSITIVE_INFINITY);
+        assertEquals(Float.POSITIVE_INFINITY, buf.getFloat(0));
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getInt",
+        args = {}
+    )
     public void testGetInt() {
         int nbytes = 4;
         byte bytes[] = new byte[nbytes];
@@ -2012,15 +1977,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getInt",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getInt",
+        args = {int.class}
+    )
     public void testGetIntint() {
         int nbytes = 4;
         byte bytes[] = new byte[nbytes];
@@ -2056,15 +2019,13 @@ public class ByteBufferTest extends AbstractBufferTest {
             //expected 
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putInt",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putInt",
+        args = {int.class}
+    )
     public void testPutInt() {
         if (buf.isReadOnly()) {
             try {
@@ -2101,16 +2062,21 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.rewind();
+        buf.putInt(Integer.MAX_VALUE);
+        assertEquals(Integer.MAX_VALUE, buf.getInt(0));
+        buf.rewind();
+        buf.putInt(Integer.MIN_VALUE);
+        assertEquals(Integer.MIN_VALUE, buf.getInt(0));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putInt",
-          methodArgs = {int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putInt",
+        args = {int.class, int.class}
+    )
     public void testPutIntint() {
         if (buf.isReadOnly()) {
             try {
@@ -2151,16 +2117,19 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.putInt(0, Integer.MAX_VALUE);
+        assertEquals(Integer.MAX_VALUE, buf.getInt(0));
+        buf.putInt(0, Integer.MIN_VALUE);
+        assertEquals(Integer.MIN_VALUE, buf.getInt(0));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getLong",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getLong",
+        args = {}
+    )
     public void testGetLong() {
         int nbytes = 8;
         byte bytes[] = new byte[nbytes];
@@ -2186,15 +2155,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getLong",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getLong",
+        args = {int.class}
+    )
     public void testGetLongint() {
         int nbytes = 8;
         byte bytes[] = new byte[nbytes];
@@ -2225,15 +2192,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putLong",
-          methodArgs = {long.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putLong",
+        args = {long.class}
+    )
     public void testPutLong() {
         if (buf.isReadOnly()) {
             try {
@@ -2270,16 +2235,21 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.rewind();
+        buf.putLong(Long.MAX_VALUE);
+        assertEquals(Long.MAX_VALUE, buf.getLong(0));
+        buf.rewind();
+        buf.putLong(Long.MIN_VALUE);
+        assertEquals(Long.MIN_VALUE, buf.getLong(0));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putLong",
-          methodArgs = {int.class, long.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putLong",
+        args = {int.class, long.class}
+    )
     public void testPutLongint() {
         if (buf.isReadOnly()) {
             try {
@@ -2320,16 +2290,19 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.putLong(0, Long.MAX_VALUE);
+        assertEquals(Long.MAX_VALUE, buf.getLong(0));
+        buf.putLong(0, Long.MIN_VALUE);
+        assertEquals(Long.MIN_VALUE, buf.getLong(0));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getShort",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getShort",
+        args = {}
+    )
     public void testGetShort() {
         int nbytes = 2;
         byte bytes[] = new byte[nbytes];
@@ -2355,15 +2328,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "getShort",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "getShort",
+        args = {int.class}
+    )
     public void testGetShortint() {
         int nbytes = 2;
         byte bytes[] = new byte[nbytes];
@@ -2394,15 +2365,13 @@ public class ByteBufferTest extends AbstractBufferTest {
 
         buf.order(ByteOrder.BIG_ENDIAN);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putShort",
-          methodArgs = {short.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putShort",
+        args = {short.class}
+    )
     public void testPutShort() {
         if (buf.isReadOnly()) {
             try {
@@ -2439,16 +2408,21 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.rewind();
+        buf.putShort(Short.MAX_VALUE);
+        assertEquals(Short.MAX_VALUE, buf.getShort(0));
+        buf.rewind();
+        buf.putShort(Short.MIN_VALUE);
+        assertEquals(Short.MIN_VALUE, buf.getShort(0));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "putShort",
-          methodArgs = {int.class, short.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "putShort",
+        args = {int.class, short.class}
+    )
     public void testPutShortint() {
         if (buf.isReadOnly()) {
             try {
@@ -2489,21 +2463,22 @@ public class ByteBufferTest extends AbstractBufferTest {
         }
 
         buf.order(ByteOrder.BIG_ENDIAN);
+
+        buf.putShort(0, Short.MAX_VALUE);
+        assertEquals(Short.MAX_VALUE, buf.getShort(0));
+        buf.putShort(0, Short.MIN_VALUE);
+        assertEquals(Short.MIN_VALUE, buf.getShort(0));
     }
     
     /**
      * @tests java.nio.ByteBuffer.wrap(byte[],int,int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Regression test. Verifies NullPointerException, " +
-            "IndexOutOfBoundsException.",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {byte[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies NullPointerException, IndexOutOfBoundsException.",
+        method = "wrap",
+        args = {byte[].class, int.class, int.class}
+    )
     public void testWrappedByteBuffer_null_array() {
         // Regression for HARMONY-264
         byte array[] = null;
@@ -2526,29 +2501,26 @@ public class ByteBufferTest extends AbstractBufferTest {
      * 2. case for check equal between buf2 and byte array[]
      * 3. case for check a buf2 dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {byte[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {byte[].class}
+    )
     public void test_Wrap$B() {
         byte array[] = new byte[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
         ByteBuffer buf2 = ByteBuffer.wrap(array);
 
-        //    case: ByteBuffer buf2 properties is satisfy the conditions specification
-        assertEquals(buf2.capacity(), array.length);
-        assertEquals(buf2.limit(), array.length);
-        assertEquals(buf2.position(), 0);
+        // case: ByteBuffer buf2 properties is satisfy the conditions specification
+        assertEquals(array.length, buf2.capacity());
+        assertEquals(array.length, buf2.limit());
+        assertEquals(0, buf2.position());
 
         //     case: ByteBuffer buf2 is equal to byte array[]
         assertContentEquals(buf2, array, 0, array.length);
 
-        //    case: ByteBuffer buf2 is depended to byte array[]
+        // case: ByteBuffer buf2 is depended to byte array[]
         loadTestData2(array, 0, buf.capacity());
         assertContentEquals(buf2, array, 0, array.length);
     }
@@ -2561,15 +2533,12 @@ public class ByteBufferTest extends AbstractBufferTest {
      * 3. case for check a buf2 dependens to array[]
      * 4. case expected IndexOutOfBoundsException  
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {byte[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {byte[].class, int.class, int.class}
+    )
     public void test_Wrap$BII() {
         byte array[] = new byte[BUFFER_LENGTH];
         int offset = 5;
@@ -2577,16 +2546,16 @@ public class ByteBufferTest extends AbstractBufferTest {
         loadTestData1(array, 0, BUFFER_LENGTH);
         ByteBuffer buf2 = ByteBuffer.wrap(array, offset, length);
 
-        //    case: ByteBuffer buf2 properties is satisfy the conditions specification
-        assertEquals(buf2.capacity(), array.length);
-        assertEquals(buf2.position(), offset);
-        assertEquals(buf2.limit(), offset + length);
-        assertEquals(buf2.arrayOffset(), 0);
+        // case: ByteBuffer buf2 properties is satisfy the conditions specification
+        assertEquals(array.length, buf2.capacity());
+        assertEquals(offset, buf2.position());
+        assertEquals(offset + length, buf2.limit());
+        assertEquals(0, buf2.arrayOffset());
 
         //     case: ByteBuffer buf2 is equal to byte array[]
         assertContentEquals(buf2, array, 0, array.length);
 
-        //    case: ByteBuffer buf2 is depended to byte array[]
+        // case: ByteBuffer buf2 is depended to byte array[]
         loadTestData2(array, 0, buf.capacity());
         assertContentEquals(buf2, array, 0, array.length);
 
@@ -2629,7 +2598,7 @@ public class ByteBufferTest extends AbstractBufferTest {
     private void assertContentEquals(ByteBuffer buf, byte array[],
             int offset, int length) {
         for (int i = 0; i < length; i++) {
-            assertEquals(buf.get(i), array[offset + i]);
+            assertEquals(array[offset + i], buf.get(i));
         }
     }
 
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteOrderTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteOrderTest.java
index 1fc82ab..069b056 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteOrderTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ByteOrderTest.java
@@ -17,46 +17,42 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteOrder;
 
 import junit.framework.TestCase;
-@TestTargetClass(ByteOrder.class)
+
 /**
  * Test java.nio.ByteOrder
  * 
  */
+@TestTargetClass(ByteOrder.class)
 public class ByteOrderTest extends TestCase {
 
     public static void main(String[] args) {
         junit.textui.TestRunner.run(ByteOrderTest.class);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         assertEquals(ByteOrder.BIG_ENDIAN.toString(), "BIG_ENDIAN");
         assertEquals(ByteOrder.LITTLE_ENDIAN.toString(), "LITTLE_ENDIAN");
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "nativeOrder",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "nativeOrder",
+        args = {}
+    )
     public void testNativeOrder() {
         ByteOrder o = ByteOrder.nativeOrder();
         assertTrue(o == ByteOrder.BIG_ENDIAN || o == ByteOrder.LITTLE_ENDIAN);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/CharBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/CharBufferTest.java
index ce394a5..21d96a5 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/CharBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/CharBufferTest.java
@@ -17,9 +17,9 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.io.IOException;
@@ -45,6 +45,7 @@ public class CharBufferTest extends AbstractBufferTest {
     private static char[] chars = "123456789a".toCharArray();
     
     protected void setUp() throws Exception{
+        capacity = chars.length;
         char[] charscopy = new char[chars.length];
         System.arraycopy(chars, 0, charscopy, 0, chars.length);
         buf = CharBuffer.wrap(charscopy);
@@ -61,22 +62,28 @@ public class CharBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check CharBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: CharBuffer testBuf properties is satisfy the conditions
         // specification
         CharBuffer testBuf = CharBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = CharBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -87,15 +94,13 @@ public class CharBufferTest extends AbstractBufferTest {
         }
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test code as in testArrayOffset method.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         char array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -112,40 +117,36 @@ public class CharBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test code as in testArrayOffset method.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         char array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = (char) i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        CharBuffer wrapped = CharBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -195,15 +196,13 @@ public class CharBufferTest extends AbstractBufferTest {
         buf.reset();
         assertEquals(buf.position(), originalPosition);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         // case: buffer is full
         buf.clear();
@@ -254,15 +253,13 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testCompareTo() {
         // compare to self
         assertEquals(0, buf.compareTo(buf));
@@ -288,15 +285,13 @@ public class CharBufferTest extends AbstractBufferTest {
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         // mark the position 0
         buf.clear();
@@ -358,15 +353,13 @@ public class CharBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -392,15 +385,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for char get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -418,15 +408,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer get(char[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify different arrays: empty, null and etc.",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {char[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {char[].class}
+    )
     public void testGetcharArray() {
         char array[] = new char[1];
         buf.clear();
@@ -436,26 +423,33 @@ public class CharBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i));
             assertSame(ret, buf);
         }
+
+        buf.get(new char[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
+        try {
+            buf.get((char[])null);
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (NullPointerException e) {
+            // expected
+        }
     }
 
     /*
      * Class under test for java.nio.CharBuffer get(char[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {char[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {char[].class, int.class, int.class}
+    )
     public void testGetcharArrayintint() {
         buf.clear();
         char array[] = new char[buf.capacity()];
@@ -523,15 +517,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for char get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -551,15 +542,13 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         loadTestData1(buf);
@@ -574,15 +563,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer put(char)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {char.class}
+    )
     public void testPutchar() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -602,15 +588,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer put(char[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {char[].class}
+    )
     public void testPutcharArray() {
         char array[] = new char[1];
 
@@ -639,15 +622,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer put(char[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {char[].class, int.class, int.class}
+    )
     public void testPutcharArrayintint() {
         buf.clear();
         char array[] = new char[buf.capacity()];
@@ -720,15 +700,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer put(java.nio.CharBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testPutCharBuffer() {
         CharBuffer other = CharBuffer.allocate(buf.capacity());
 
@@ -771,15 +748,12 @@ public class CharBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.CharBuffer put(int, char)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, char.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, char.class}
+    )
     public void testPutintchar() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -801,15 +775,13 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -819,9 +791,9 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(buf.isReadOnly(), slice.isReadOnly());
         assertEquals(buf.isDirect(), slice.isDirect());
         assertEquals(buf.order(), slice.order());
-        assertEquals(slice.position(), 0);
-        assertEquals(slice.limit(), buf.remaining());
-        assertEquals(slice.capacity(), buf.remaining());
+        assertEquals(0, slice.position());
+        assertEquals(buf.remaining(), slice.limit());
+        assertEquals(buf.remaining(), slice.capacity());
         try {
             slice.reset();
             fail("Should throw Exception"); //$NON-NLS-1$
@@ -837,15 +809,13 @@ public class CharBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String expected = "";
         for (int i = buf.position(); i < buf.limit(); i++) {
@@ -854,15 +824,13 @@ public class CharBufferTest extends AbstractBufferTest {
         String str = buf.toString();
         assertEquals(expected, str);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "charAt",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "charAt",
+        args = {int.class}
+    )
     public void testCharAt() {
         for (int i = 0; i < buf.remaining(); i++) {
             assertEquals(buf.get(buf.position() + i), buf.charAt(i));
@@ -880,27 +848,23 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "length",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "length",
+        args = {}
+    )
     public void testLength() {
         assertEquals(buf.length(), buf.remaining());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "subSequence",
-          methodArgs = {int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "subSequence",
+        args = {int.class, int.class}
+    )
     public void testSubSequence() {
         try {
             buf.subSequence(-1, buf.length());
@@ -936,15 +900,13 @@ public class CharBufferTest extends AbstractBufferTest {
                     .toString().substring(1, buf.length() - 1));
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.lang.String.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.lang.String.class}
+    )
     public void testPutString() {
         String str = " ";
 
@@ -969,15 +931,13 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.lang.String.class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.lang.String.class, int.class, int.class}
+    )
     public void testPutStringintint() {
         buf.clear();
         String str = String.valueOf(new char[buf.capacity()]);
@@ -1092,16 +1052,13 @@ public class CharBufferTest extends AbstractBufferTest {
             value = (char) (value + 1);
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies append method with the same CharSequence object " +
-            "for which it's called.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies append method with the same CharSequence object for which it's called.",
+        method = "append",
+        args = {java.lang.CharSequence.class}
+    )
     public void testAppendSelf() throws Exception {
         CharBuffer cb = CharBuffer.allocate(10);
         CharBuffer cb2 = cb.duplicate();
@@ -1127,21 +1084,25 @@ public class CharBufferTest extends AbstractBufferTest {
         cb2.clear();
         assertEquals(cb, cb2);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies BufferOverflowException.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {char.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies BufferOverflowException.",
+            method = "append",
+            args = {char.class}
         ),
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies BufferOverflowException.",
+            method = "append",
+            args = {java.lang.CharSequence.class}
         ),
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies BufferOverflowException.",
+            method = "append",
+            args = {java.lang.CharSequence.class, int.class, int.class}
         )
     })
     public void testAppendOverFlow() throws IOException {
@@ -1167,21 +1128,25 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected;
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {char.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies ReadOnlyBufferException.",
+            method = "append",
+            args = {char.class}
         ),
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies ReadOnlyBufferException.",
+            method = "append",
+            args = {java.lang.CharSequence.class}
         ),
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies ReadOnlyBufferException.",
+            method = "append",
+            args = {java.lang.CharSequence.class, int.class, int.class}
         )
     })
     public void testReadOnlyMap() throws IOException {
@@ -1207,30 +1172,26 @@ public class CharBufferTest extends AbstractBufferTest {
         }
         cb.append(cs, 1, 1);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify exceptions.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {char.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exceptions.",
+        method = "append",
+        args = {char.class}
+    )
     public void testAppendCNormal() throws IOException {
         CharBuffer cb = CharBuffer.allocate(2);
         cb.put('A');
         assertSame(cb, cb.append('B'));
         assertEquals('B', cb.get(1));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify exceptions.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exceptions.",
+        method = "append",
+        args = {java.lang.CharSequence.class}
+    )
     public void testAppendCharSequenceNormal() throws IOException {
         CharBuffer cb = CharBuffer.allocate(10);
         cb.put('A');
@@ -1239,16 +1200,13 @@ public class CharBufferTest extends AbstractBufferTest {
         cb.append(null);
         assertEquals("null", cb.flip().toString());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies positive case, and null as CharSequence " +
-            "parameter.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies positive case, and null as CharSequence parameter.",
+        method = "append",
+        args = {java.lang.CharSequence.class, int.class, int.class}
+    )
     public void testAppendCharSequenceIINormal() throws IOException {
         CharBuffer cb = CharBuffer.allocate(10);
         cb.put('A');
@@ -1258,15 +1216,13 @@ public class CharBufferTest extends AbstractBufferTest {
         cb.append(null, 0, 1);
         assertEquals("n", cb.flip().toString());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies IndexOutOfBoundsException.",
-      targets = {
-        @TestTarget(
-          methodName = "append",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException.",
+        method = "append",
+        args = {java.lang.CharSequence.class, int.class, int.class}
+    )
     public void testAppendCharSequenceII_IllegalArgument() throws IOException {
         CharBuffer cb = CharBuffer.allocate(10);
         cb.append("String", 0, 0);
@@ -1302,15 +1258,13 @@ public class CharBufferTest extends AbstractBufferTest {
             // expected;
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "read",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testReadCharBuffer() throws IOException {
         CharBuffer source = CharBuffer.wrap("String");
         CharBuffer target = CharBuffer.allocate(10);
@@ -1327,15 +1281,13 @@ public class CharBufferTest extends AbstractBufferTest {
         }
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "read",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testReadReadOnly() throws IOException {
         CharBuffer source = CharBuffer.wrap("String");
         CharBuffer target = CharBuffer.allocate(10).asReadOnlyBuffer();
@@ -1349,16 +1301,13 @@ public class CharBufferTest extends AbstractBufferTest {
         target.flip();
         assertEquals(0, source.read(target));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies read method with CharBuffer parameter which length " +
-            "is less than read CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies read method with CharBuffer parameter which length is less than read CharBuffer.",
+        method = "read",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testReadOverflow() throws IOException {
         CharBuffer source = CharBuffer.wrap("String");
         CharBuffer target = CharBuffer.allocate(1);
@@ -1366,15 +1315,13 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals("S", target.flip().toString());
         assertEquals(1, source.position());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "read",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testReadSelf() throws Exception {
         CharBuffer source = CharBuffer.wrap("abuffer");
         try {
@@ -1384,51 +1331,55 @@ public class CharBufferTest extends AbstractBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Abstract method.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Abstract method.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify false returned value.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
-        assertTrue(buf.hasArray());
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.nativeOrder(), buf.order());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Abstract method.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Abstract method.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertFalse(buf.isReadOnly());
     }
@@ -1439,15 +1390,12 @@ public class CharBufferTest extends AbstractBufferTest {
      * for check equal between buf2 and char array[] 3. case for check a buf2
      * dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {char[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {char[].class}
+    )
     public void test_Wrap$C() {
         char array[] = new char[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -1475,15 +1423,12 @@ public class CharBufferTest extends AbstractBufferTest {
      * 3. case for check a buf2 dependens to array[]
      * 4. case expected IndexOutOfBoundsException  
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {char[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {char[].class, int.class, int.class}
+    )
     public void test_Wrap$CII() {
         char array[] = new char[BUFFER_LENGTH];
         int offset = 5;
@@ -1491,20 +1436,20 @@ public class CharBufferTest extends AbstractBufferTest {
         loadTestData1(array, 0, BUFFER_LENGTH);
         CharBuffer buf2 = CharBuffer.wrap(array, offset, length);
 
-        //    case: CharBuffer buf2 properties is satisfy the conditions specification
+        // case: CharBuffer buf2 properties is satisfy the conditions specification
         assertEquals(buf2.capacity(), array.length);
         assertEquals(buf2.position(), offset);
         assertEquals(buf2.limit(), offset + length);
         assertEquals(buf2.arrayOffset(), 0);
 
-        //     case: CharBuffer buf2 is equal to char array[]
+        // case: CharBuffer buf2 is equal to char array[]
         assertContentEquals(buf2, array, 0, array.length);
 
-        //    case: CharBuffer buf2 is depended to char array[]
+        // case: CharBuffer buf2 is depended to char array[]
         loadTestData2(array, 0, buf.capacity());
         assertContentEquals(buf2, array, 0, array.length);
 
-        //     case: expected IndexOutOfBoundsException
+        // case: expected IndexOutOfBoundsException
         try {
             offset = 7;
             buf2 = CharBuffer.wrap(array, offset, length);
@@ -1522,19 +1467,16 @@ public class CharBufferTest extends AbstractBufferTest {
      * 3. case for check String
      * 4. case for check CharBuffer
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {java.lang.CharSequence.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {java.lang.CharSequence.class}
+    )
     public void test_WrapLjava_lang_CharSequence() {
         // added this if clause to prevent Tests failing under special conditions. 
         // If the test extending this test is made for a read only buffer it fails 
-        // when it trys to call loadTestData1.
+        // when it tries to call loadTestData1.
         if(buf.isReadOnly()) {
             char[] charscopy = new char[chars.length];
             System.arraycopy(chars, 0, charscopy, 0, chars.length);
@@ -1554,7 +1496,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStrBf.position(), 0);
         assertContentEquals(bufStrBf, buf);
 
-        //    case: StringBuilder
+        // case: StringBuilder
         CharBuffer bufStrBl = CharBuffer.wrap(testStrBuilder);
         assertTrue(bufStrBl.isReadOnly());
         assertEquals(bufStrBl.capacity(), testStrBuilder.length());
@@ -1562,7 +1504,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStrBl.position(), 0);
         assertContentEquals(bufStrBl, buf);
 
-        //    case: String
+        // case: String
         CharBuffer bufStr = CharBuffer.wrap(testStr);
         assertTrue(bufStr.isReadOnly());
         assertEquals(bufStr.capacity(), testStr.length());
@@ -1570,7 +1512,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStr.position(), 0);
         assertContentEquals(bufStr, buf);
 
-        //    case: CharBuffer
+        // case: CharBuffer
         CharBuffer bufChBf = CharBuffer.wrap(buf);
         assertTrue(bufChBf.isReadOnly());
         assertEquals(bufChBf.capacity(), buf.length());
@@ -1587,21 +1529,18 @@ public class CharBufferTest extends AbstractBufferTest {
      * 3. case for check String
      * 4. case for check CharBuffer
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify exception.",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exception.",
+        method = "wrap",
+        args = {java.lang.CharSequence.class, int.class, int.class}
+    )
     public void test_WrapLjava_lang_CharSequenceII() {
         int start = buf.position();
         int end = buf.limit();
         CharBuffer buf2 = CharBuffer.wrap(buf.toString() + buf.toString()); //buf.toString() + buf.toString()  //"123456789a123456789a"
 
-        //case: StringBuffer
+        // case: StringBuffer
         StringBuffer testStrBuffer = new StringBuffer(buf2);
         CharBuffer bufStrBf = CharBuffer.wrap(testStrBuffer, start, end);
         assertTrue(bufStrBf.isReadOnly());
@@ -1610,7 +1549,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStrBf.position(), start);
         assertEquals(bufStrBf.toString(), buf.toString());
 
-        //    case: StringBuilder
+        // case: StringBuilder
         StringBuilder testStrBuilder = new StringBuilder(buf2);
         CharBuffer bufStrBl = CharBuffer.wrap(testStrBuilder, start, end);
         assertTrue(bufStrBl.isReadOnly());
@@ -1619,7 +1558,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStrBl.position(), start);
         assertEquals(bufStrBl.toString(), buf.toString());
 
-        //    case: String
+        // case: String
         String testStr = new String(buf2.toString());
         CharBuffer bufStr = CharBuffer.wrap(testStr, start, end);
         assertTrue(bufStr.isReadOnly());
@@ -1628,7 +1567,7 @@ public class CharBufferTest extends AbstractBufferTest {
         assertEquals(bufStr.position(), start);
         assertEquals(bufStr.toString(), buf.toString());
 
-        //    case: CharBuffer
+        // case: CharBuffer
         CharBuffer bufChBf = CharBuffer.wrap(buf2, start, end);
         assertTrue(bufChBf.isReadOnly());
         assertEquals(bufChBf.capacity(), buf2.length());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectByteBufferTest.java
index 20f3f8f..08e4813 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectByteBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -27,6 +26,7 @@ public class DirectByteBufferTest extends ByteBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH);
         baseBuf = buf;
     }
@@ -41,15 +41,12 @@ public class DirectByteBufferTest extends ByteBufferTest {
      * @tests java.nio.ByteBuffer#allocateDirect(int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocateDirect",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocateDirect",
+        args = {int.class}
+    )
     public void testAllocatedByteBuffer_IllegalArg() {
         try {
             ByteBuffer.allocateDirect(-1);
@@ -58,39 +55,69 @@ public class DirectByteBufferTest extends ByteBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isDirect method for direct ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
+    public void testArray() {
+        try {
+            buf.array();
+            fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
+    public void testArrayOffset() {
+        try {
+            buf.arrayOffset();
+            fail("Should throw UnsupportedOperationException"); //$NON-NLS-1$
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct ByteBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for direct ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct ByteBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
+        try {
+            buf.array();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (UnsupportedOperationException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for direct ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for direct ByteBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertFalse(buf.isReadOnly());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectCharBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectCharBufferTest.java
index 0a7c91d..fb55e1d 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectCharBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectCharBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -27,6 +26,7 @@ import java.nio.ByteOrder;
 public class DirectCharBufferTest extends CharBufferTest {
     
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*2).asCharBuffer();
         super.loadTestData1(buf);
         baseBuf = buf;
@@ -36,27 +36,23 @@ public class DirectCharBufferTest extends CharBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies hasArray method for direct CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct CharBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct CharBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -64,15 +60,13 @@ public class DirectCharBufferTest extends CharBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct CharBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -80,27 +74,23 @@ public class DirectCharBufferTest extends CharBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isDirect method for direct CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct CharBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectDoubleBufferTest.java
index f157fb1..afc9b03 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectDoubleBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -26,6 +25,7 @@ import java.nio.ByteOrder;
 @TestTargetClass(java.nio.DoubleBuffer.class)
 public class DirectDoubleBufferTest extends DoubleBufferTest {
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*8).asDoubleBuffer();
         loadTestData1(buf);
         baseBuf = buf;
@@ -35,27 +35,23 @@ public class DirectDoubleBufferTest extends DoubleBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies hasArray method for direct DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct DoubleBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct DoubleBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -63,15 +59,13 @@ public class DirectDoubleBufferTest extends DoubleBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct DoubleBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -79,27 +73,23 @@ public class DirectDoubleBufferTest extends DoubleBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for direct DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct DoubleBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies order method for direct DoubleBuffer.",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectFloatBufferTest.java
index 3a48c70..2c614c1 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectFloatBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -26,6 +25,7 @@ import java.nio.ByteOrder;
 @TestTargetClass(java.nio.FloatBuffer.class)
 public class DirectFloatBufferTest extends FloatBufferTest {
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*4).asFloatBuffer();
         loadTestData1(buf);
         baseBuf = buf;
@@ -35,27 +35,23 @@ public class DirectFloatBufferTest extends FloatBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for direct FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct FloatBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct FloatBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -63,15 +59,13 @@ public class DirectFloatBufferTest extends FloatBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct FloatBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -80,27 +74,23 @@ public class DirectFloatBufferTest extends FloatBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for direct FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct FloatBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies order method for direct FloatBuffer.",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectIntBufferTest.java
index b28cab0..4e72a43 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectIntBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -26,6 +25,7 @@ import java.nio.ByteOrder;
 @TestTargetClass(java.nio.IntBuffer.class)
 public class DirectIntBufferTest extends IntBufferTest {
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*4).asIntBuffer();
         loadTestData1(buf);
         baseBuf = buf;
@@ -35,27 +35,23 @@ public class DirectIntBufferTest extends IntBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for direct IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct IntBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct IntBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -63,15 +59,13 @@ public class DirectIntBufferTest extends IntBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct IntBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -80,27 +74,23 @@ public class DirectIntBufferTest extends IntBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for direct IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct IntBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies order method for direct IntBuffer.",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectLongBufferTest.java
index c148aba..9653960 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectLongBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -26,6 +25,7 @@ import java.nio.ByteOrder;
 @TestTargetClass(java.nio.LongBuffer.class)
 public class DirectLongBufferTest extends LongBufferTest {
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*8).asLongBuffer();
         loadTestData1(buf);
         baseBuf = buf;
@@ -35,27 +35,23 @@ public class DirectLongBufferTest extends LongBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for direct LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct LongBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct LongBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -63,15 +59,13 @@ public class DirectLongBufferTest extends LongBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct LongBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -80,27 +74,23 @@ public class DirectLongBufferTest extends LongBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for direct LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct LongBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies order method for direct LongBuffer.",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectShortBufferTest.java
index 184adb9..a76701f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DirectShortBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -26,6 +25,7 @@ import java.nio.ByteOrder;
 @TestTargetClass(java.nio.ShortBuffer.class)
 public class DirectShortBufferTest extends ShortBufferTest {
     public void setUp(){
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocateDirect(BUFFER_LENGTH*2).asShortBuffer();
         loadTestData1(buf);
         baseBuf = buf;
@@ -35,27 +35,23 @@ public class DirectShortBufferTest extends ShortBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for direct ShortBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies array method for direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies array method for direct ShortBuffer.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -63,15 +59,13 @@ public class DirectShortBufferTest extends ShortBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies arrayOffset method for direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies arrayOffset method for direct ShortBuffer.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
@@ -80,27 +74,23 @@ public class DirectShortBufferTest extends ShortBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for direct ShortBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertTrue(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies order method for direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies order method for direct ShortBuffer.",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.BIG_ENDIAN, buf.order());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DoubleBufferTest.java
index 64b0c97..44f0ae7 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DoubleBufferTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -42,6 +41,7 @@ public class DoubleBufferTest extends AbstractBufferTest {
     protected DoubleBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = BUFFER_LENGTH;
         buf = DoubleBuffer.allocate(BUFFER_LENGTH);
         loadTestData1(buf);
         baseBuf = buf;
@@ -57,22 +57,28 @@ public class DoubleBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check DoubleBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verifies boundary value.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: DoubleBuffer testBuf properties is satisfy the conditions
         // specification
         DoubleBuffer testBuf = DoubleBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = DoubleBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -87,15 +93,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
      * Test with bit sequences that represent the IEEE754 doubles Positive
      * infinity, negative infinity, and NaN.
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies boundary values.",
+        method = "put",
+        args = {double.class}
+    )
     public void testNaNs() {
         long[] nans = new long[] { 0x7ff0000000000000L, 0xfff0000000000000L,
                 0x7ff8000000000000L };
@@ -116,15 +119,13 @@ public class DoubleBufferTest extends AbstractBufferTest {
             assertTrue(longBitsIn == bufLongOut);
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArrayOffset.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         double array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -141,40 +142,36 @@ public class DoubleBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArray.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         double array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        DoubleBuffer wrapped = DoubleBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -197,16 +194,28 @@ public class DoubleBufferTest extends AbstractBufferTest {
         assertEquals(buf.position(), buf.limit());
         buf.reset();
         assertEquals(buf.position(), 0);
+
+        // BEGIN android-added
+        // copied from a newer version of Harmony
+        DoubleBuffer dbuffer1 = DoubleBuffer.wrap(new double[] { Double.NaN });
+        DoubleBuffer dbuffer2 = DoubleBuffer.wrap(new double[] { Double.NaN });
+        DoubleBuffer dbuffer3 = DoubleBuffer.wrap(new double[] { 42d });
+
+        assertEquals("Failed equal comparison with NaN entry", 0, dbuffer1
+                .compareTo(dbuffer2));
+        assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer3
+                .compareTo(dbuffer1));
+        assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer1
+                .compareTo(dbuffer3));
+        // END android-added
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         // case: buffer is full
         buf.clear();
@@ -257,15 +266,13 @@ public class DoubleBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.DoubleBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.DoubleBuffer.class}
+    )
     public void testCompareTo() {
         DoubleBuffer other = DoubleBuffer.allocate(buf.capacity());
         loadTestData1(other);
@@ -281,27 +288,14 @@ public class DoubleBufferTest extends AbstractBufferTest {
         other.limit(5);
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
-
-        DoubleBuffer dbuffer1 = DoubleBuffer.wrap(new double[] { Double.NaN });
-        DoubleBuffer dbuffer2 = DoubleBuffer.wrap(new double[] { Double.NaN });
-        DoubleBuffer dbuffer3 = DoubleBuffer.wrap(new double[] { 42d });
-
-        assertEquals("Failed equal comparison with NaN entry", 0, dbuffer1
-                .compareTo(dbuffer2));
-        assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer3
-                .compareTo(dbuffer1));
-        assertEquals("Failed greater than comparison with NaN entry", 1, dbuffer1
-                .compareTo(dbuffer3));
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -334,15 +328,13 @@ public class DoubleBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -368,15 +360,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for double get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -394,15 +383,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer get(double[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {double[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {double[].class}
+    )
     public void testGetdoubleArray() {
         double array[] = new double[1];
         buf.clear();
@@ -412,26 +398,33 @@ public class DoubleBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i), 0.01);
             assertSame(ret, buf);
         }
+
+        buf.get(new double[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
+        try {
+            buf.get((double[])null);
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (NullPointerException e) {
+            // expected
+        }
     }
 
     /*
      * Class under test for java.nio.DoubleBuffer get(double[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {double[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {double[].class, int.class, int.class}
+    )
     public void testGetdoubleArrayintint() {
         buf.clear();
         double array[] = new double[buf.capacity()];
@@ -499,15 +492,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for double get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -527,27 +517,35 @@ public class DoubleBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify false returned value.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
-        assertTrue(buf.hasArray());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         DoubleBuffer readonly = buf.asReadOnlyBuffer();
@@ -558,27 +556,23 @@ public class DoubleBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity() / 2);
         assertTrue(buf.hashCode() != duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify direct buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify direct buffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         assertEquals(ByteOrder.nativeOrder(), buf.order());
     }
@@ -586,15 +580,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer put(double)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify boundary values, and ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify boundary values, and ReadOnlyBufferException.",
+        method = "put",
+        args = {double.class}
+    )
     public void testPutdouble() {
 
         buf.clear();
@@ -615,15 +606,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer put(double[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {double[].class}
+    )
     public void testPutdoubleArray() {
         double array[] = new double[1];
 
@@ -646,15 +634,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer put(double[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {double[].class, int.class, int.class}
+    )
     public void testPutdoubleArrayintint() {
         buf.clear();
         double array[] = new double[buf.capacity()];
@@ -722,15 +707,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer put(java.nio.DoubleBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.DoubleBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.DoubleBuffer.class}
+    )
     public void testPutDoubleBuffer() {
         DoubleBuffer other = DoubleBuffer.allocate(buf.capacity());
 
@@ -760,15 +742,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.DoubleBuffer put(int, double)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, double.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, double.class}
+    )
     public void testPutintdouble() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -790,15 +769,13 @@ public class DoubleBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -827,15 +804,13 @@ public class DoubleBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500, 0.0);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Double") >= 0 || str.indexOf("double") >= 0);
@@ -850,15 +825,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
      * case for check equal between buf2 and double array[] 3. case for check a
      * buf2 dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {double[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {double[].class}
+    )
     public void test_Wrap$D() {
         double array[] = new double[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -885,15 +857,12 @@ public class DoubleBufferTest extends AbstractBufferTest {
      * 3. case for check a buf2 dependens to array[] 4. case expected
      * IndexOutOfBoundsException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {double[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {double[].class, int.class, int.class}
+    )
     public void test_Wrap$DII() {
         double array[] = new double[BUFFER_LENGTH];
         int offset = 5;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateHeapByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateHeapByteBufferTest.java
index 29af679..1335bb8 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateHeapByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateHeapByteBufferTest.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateWrappedByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateWrappedByteBufferTest.java
index 7b38bac..d967387 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateWrappedByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/DuplicateWrappedByteBufferTest.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/FloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/FloatBufferTest.java
index 67f2c2d..f140dd2 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/FloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/FloatBufferTest.java
@@ -17,15 +17,14 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
 import java.nio.BufferUnderflowException;
+import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
-import java.nio.DoubleBuffer;
 import java.nio.FloatBuffer;
 import java.nio.InvalidMarkException;
 
@@ -43,6 +42,7 @@ public class FloatBufferTest extends AbstractBufferTest {
     protected FloatBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = BUFFER_LENGTH;
         buf = FloatBuffer.allocate(BUFFER_LENGTH);
         loadTestData1(buf);
         baseBuf = buf;
@@ -58,22 +58,28 @@ public class FloatBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check FloatBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify boundary case.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: FloatBuffer testBuf properties is satisfy the conditions
         // specification
         FloatBuffer testBuf = FloatBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = FloatBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -83,15 +89,39 @@ public class FloatBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArrayOffset.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies boundary values.",
+        method = "put",
+        args = {float.class}
+    )
+    public void testNaNs() {
+        int[] nans = new int[] { 0x7f800000, 0xff800000, 0x7fc00000 };
+        for (int i = 0; i < nans.length; i++) {
+            int intBitsIn = nans[i];
+            float flt = Float.intBitsToFloat(intBitsIn);
+            int intBitsOut = Float.floatToRawIntBits(flt);
+            // Sanity check
+            assertTrue(intBitsIn == intBitsOut);
+
+            // Store the float and retrieve it
+            ByteBuffer buffer = ByteBuffer.allocate(8);
+            buffer.putFloat(flt);
+            float bufFloatOut = buffer.getFloat(0);
+
+            // Check the bits sequence was not normalized
+            int bufIntOut = Float.floatToRawIntBits(bufFloatOut);
+            assertTrue(intBitsIn == bufIntOut);
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         float array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -108,40 +138,36 @@ public class FloatBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArray.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         float array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        FloatBuffer wrapped = FloatBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -165,15 +191,13 @@ public class FloatBufferTest extends AbstractBufferTest {
         buf.reset();
         assertEquals(buf.position(), 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
 
         // case: buffer is full
@@ -225,15 +249,13 @@ public class FloatBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.FloatBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.FloatBuffer.class}
+    )
     public void testCompareTo() {
         try {
             buf.compareTo(null);    
@@ -262,7 +284,9 @@ public class FloatBufferTest extends AbstractBufferTest {
         other.limit(5);
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
-        
+
+        // BEGIN android-added
+        // copied from a newer version of Harmony
         FloatBuffer fbuffer1 = FloatBuffer.wrap(new float[] { Float.NaN });
         FloatBuffer fbuffer2 = FloatBuffer.wrap(new float[] { Float.NaN });
         FloatBuffer fbuffer3 = FloatBuffer.wrap(new float[] { 42f });
@@ -273,17 +297,15 @@ public class FloatBufferTest extends AbstractBufferTest {
                 .compareTo(fbuffer1));
         assertEquals("Failed greater than comparison with NaN entry", 1, fbuffer1
                 .compareTo(fbuffer3));
-
+        // END android-added
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -315,15 +337,13 @@ public class FloatBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -349,15 +369,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for float get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -375,15 +392,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer get(float[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {float[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {float[].class}
+    )
     public void testGetfloatArray() {
         float array[] = new float[1];
         buf.clear();
@@ -393,34 +407,33 @@ public class FloatBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i), 0.01);
             assertSame(ret, buf);
         }
+
+        buf.get(new float[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
         try {
-            buf.position(buf.limit());
             buf.get((float[])null);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (NullPointerException e) {
             // expected
         }
-        buf.get(new float[0]);
     }
 
     /*
      * Class under test for java.nio.FloatBuffer get(float[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {float[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {float[].class, int.class, int.class}
+    )
     public void testGetfloatArrayintint() {
         buf.clear();
         float array[] = new float[buf.capacity()];
@@ -488,15 +501,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for float get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -516,27 +526,35 @@ public class FloatBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that array method doesn't return null.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
-        assertNotNull(buf.array());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         FloatBuffer readonly = buf.asReadOnlyBuffer();
@@ -547,27 +565,23 @@ public class FloatBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity() / 2);
         assertTrue(buf.hashCode() != duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify direct buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify direct buffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
         buf.order();
         if (buf.hasArray()) {
@@ -578,15 +592,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer put(float)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {float.class}
+    )
     public void testPutfloat() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -606,15 +617,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer put(float[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {float[].class}
+    )
     public void testPutfloatArray() {
         float array[] = new float[1];
         buf.clear();
@@ -643,15 +651,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer put(float[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {float[].class, int.class, int.class}
+    )
     public void testPutfloatArrayintint() {
         buf.clear();
         float array[] = new float[buf.capacity()];
@@ -718,15 +723,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer put(java.nio.FloatBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.FloatBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.FloatBuffer.class}
+    )
     public void testPutFloatBuffer() {
         FloatBuffer other = FloatBuffer.allocate(buf.capacity());
         try {
@@ -762,15 +764,12 @@ public class FloatBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.FloatBuffer put(int, float)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, float.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, float.class}
+    )
     public void testPutintfloat() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -792,15 +791,13 @@ public class FloatBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -828,15 +825,13 @@ public class FloatBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500, 0.0);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Float") >= 0 || str.indexOf("float") >= 0);
@@ -851,15 +846,12 @@ public class FloatBufferTest extends AbstractBufferTest {
      * for check equal between buf2 and float array[] 3. case for check a buf2
      * dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {float[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {float[].class}
+    )
     public void test_Wrap$S() {
         float array[] = new float[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -886,15 +878,12 @@ public class FloatBufferTest extends AbstractBufferTest {
      * case for check a buf2 dependens to array[] 4. case expected
      * IndexOutOfBoundsException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {float[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {float[].class, int.class, int.class}
+    )
     public void test_Wrap$SII() {
         float array[] = new float[BUFFER_LENGTH];
         int offset = 5;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapByteBufferTest.java
index 13949e6..046350f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapByteBufferTest.java
@@ -13,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -28,6 +26,7 @@ public class HeapByteBufferTest extends ByteBufferTest {
     
     protected void setUp() throws Exception {   
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.allocate(BUFFER_LENGTH);
         baseBuf = buf;
     }
@@ -42,15 +41,12 @@ public class HeapByteBufferTest extends ByteBufferTest {
      * @tests java.nio.ByteBuffer#allocate(int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedByteBuffer_IllegalArg() {
         try {
             ByteBuffer.allocate(-1);
@@ -59,39 +55,34 @@ public class HeapByteBufferTest extends ByteBufferTest {
             // expected 
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isDirect method with not direct buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method with not direct buffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that hasArray returns true value.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that hasArray returns true value.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertTrue(buf.hasArray());
+        assertNotNull(buf.array());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method with non read only buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method with non read only buffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertFalse(buf.isReadOnly());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapCharBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapCharBufferTest.java
index ba9e681..5c370a2 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapCharBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapCharBufferTest.java
@@ -13,12 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.CharBuffer;
@@ -27,9 +25,6 @@ import java.nio.CharBuffer;
 public class HeapCharBufferTest extends CharBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = CharBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -37,15 +32,13 @@ public class HeapCharBufferTest extends CharBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedCharBuffer_IllegalArg() {
         try {
             CharBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapDoubleBufferTest.java
index e5f8c3e..ddef05f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapDoubleBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.DoubleBuffer;
@@ -26,9 +25,6 @@ import java.nio.DoubleBuffer;
 public class HeapDoubleBufferTest extends DoubleBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = DoubleBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -36,15 +32,13 @@ public class HeapDoubleBufferTest extends DoubleBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedDoubleBuffer_IllegalArg() {
         try {
             DoubleBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapFloatBufferTest.java
index 2d1f7fd..2a323c5 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapFloatBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.FloatBuffer;
@@ -26,9 +25,6 @@ import java.nio.FloatBuffer;
 public class HeapFloatBufferTest extends FloatBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = FloatBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -36,15 +32,13 @@ public class HeapFloatBufferTest extends FloatBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedFloatBuffer_IllegalArg() {
         try {
             FloatBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapIntBufferTest.java
index 946f75c..b92f7c6 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapIntBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.IntBuffer;
@@ -26,9 +25,6 @@ import java.nio.IntBuffer;
 public class HeapIntBufferTest extends IntBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = IntBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -36,15 +32,13 @@ public class HeapIntBufferTest extends IntBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedIntBuffer_IllegalArg() {
         try {
             IntBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapLongBufferTest.java
index a08d93e..7beedbb 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapLongBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.LongBuffer;
@@ -26,9 +25,6 @@ import java.nio.LongBuffer;
 public class HeapLongBufferTest extends LongBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = LongBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -36,15 +32,13 @@ public class HeapLongBufferTest extends LongBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedLongBuffer_IllegalArg() {
         try {
             LongBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapShortBufferTest.java
index 15d7f0a..4de5229 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/HeapShortBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ShortBuffer;
@@ -26,9 +25,6 @@ import java.nio.ShortBuffer;
 public class HeapShortBufferTest extends ShortBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
-        buf = ShortBuffer.allocate(BUFFER_LENGTH); 
-        loadTestData1(buf);
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
@@ -36,15 +32,13 @@ public class HeapShortBufferTest extends ShortBufferTest {
         buf = null;
         baseBuf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "allocate",
+        args = {int.class}
+    )
     public void testAllocatedShortBuffer_IllegalArg() {
         try {
             ShortBuffer.allocate(-1);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/IntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/IntBufferTest.java
index 308bfd6..1f26d5e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/IntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/IntBufferTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -43,6 +42,7 @@ public class IntBufferTest extends AbstractBufferTest {
     protected IntBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = BUFFER_LENGTH;
         buf = IntBuffer.allocate(BUFFER_LENGTH);
         loadTestData1(buf);
         baseBuf = buf;
@@ -58,22 +58,28 @@ public class IntBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check IntBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't veify boundary values.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: IntBuffer testBuf properties is satisfy the conditions
         // specification
         IntBuffer testBuf = IntBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = IntBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -83,15 +89,13 @@ public class IntBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArrayOffset.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         int array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -108,40 +112,36 @@ public class IntBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArray.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public  void testArrayOffset() {
         int array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        IntBuffer wrapped = IntBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
      }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public  void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -165,15 +165,13 @@ public class IntBufferTest extends AbstractBufferTest {
         buf.reset();
         assertEquals(buf.position(), 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public  void testCompact() {
         // case: buffer is full
         buf.clear();
@@ -224,15 +222,13 @@ public class IntBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.IntBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.IntBuffer.class}
+    )
     public  void testCompareTo() {
         // compare to self
         assertEquals(0, buf.compareTo(buf));
@@ -255,15 +251,13 @@ public class IntBufferTest extends AbstractBufferTest {
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public  void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -295,15 +289,13 @@ public class IntBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public  void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -329,15 +321,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for int get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public  void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -355,15 +344,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer get(int[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int[].class}
+    )
     public  void testGetintArray() {
         int array[] = new int[1];
         buf.clear();
@@ -373,12 +359,16 @@ public class IntBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i));
             assertSame(ret, buf);
         }
+
+        buf.get(new int[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
         try {
             buf.get((int[])null);
             fail("Should throw NPE"); //$NON-NLS-1$
@@ -390,15 +380,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer get(int[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int[].class, int.class, int.class}
+    )
     public  void testGetintArrayintint() {
         buf.clear();
         int array[] = new int[buf.capacity()];
@@ -466,15 +453,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for int get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public  void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -494,27 +478,35 @@ public class IntBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that array method doesn't return null.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public  void testHasArray() {
-        assertNotNull(buf.array());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public  void testHashCode() {
         buf.clear();
         IntBuffer readonly = buf.asReadOnlyBuffer();
@@ -525,44 +517,36 @@ public class IntBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity() / 2);
         assertTrue(buf.hashCode() != duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for non direct buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for non direct buffer.",
+        method = "isDirect",
+        args = {}
+    )
     public  void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public  void testOrder() {
-        buf.order();
         assertEquals(ByteOrder.nativeOrder(), buf.order());
     }
 
     /*
      * Class under test for java.nio.IntBuffer put(int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class}
+    )
     public  void testPutint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -582,15 +566,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer put(int[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int[].class}
+    )
     public  void testPutintArray() {
         int array[] = new int[1];
         buf.clear();
@@ -619,15 +600,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer put(int[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int[].class, int.class, int.class}
+    )
     public  void testPutintArrayintint() {
         buf.clear();
         int array[] = new int[buf.capacity()];
@@ -694,15 +672,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer put(java.nio.IntBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.IntBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.IntBuffer.class}
+    )
     public  void testPutIntBuffer() {
         IntBuffer other = IntBuffer.allocate(buf.capacity());
         try {
@@ -738,15 +713,12 @@ public class IntBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.IntBuffer put(int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, int.class}
+    )
     public  void testPutintint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -768,15 +740,13 @@ public class IntBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public  void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -804,15 +774,13 @@ public class IntBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public  void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Int") >= 0 || str.indexOf("int") >= 0);
@@ -827,15 +795,12 @@ public class IntBufferTest extends AbstractBufferTest {
      * equal between buf2 and int array[] 3. case for check a buf2 dependens to
      * array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {int[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {int[].class}
+    )
     public void test_Wrap$I() {
         int array[] = new int[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -862,15 +827,12 @@ public class IntBufferTest extends AbstractBufferTest {
      * for check a buf2 dependens to array[] 4. case expected
      * IndexOutOfBoundsException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {int[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {int[].class, int.class, int.class}
+    )
     public void test_Wrap$III() {
         int array[] = new int[BUFFER_LENGTH];
         int offset = 5;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/InvalidMarkExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/InvalidMarkExceptionTest.java
index b18d3da..3fd32f5 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/InvalidMarkExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/InvalidMarkExceptionTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.InvalidMarkException;
@@ -32,15 +31,12 @@ public class InvalidMarkExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies serialization/deserialization compatibility.",
+        method = "!SerializationSelf",
+        args = {}
+    )    
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new InvalidMarkException());
@@ -49,17 +45,33 @@ public class InvalidMarkExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies serialization/deserialization compatibility.",
+        method = "!SerializationGolden",
+        args = {}
+    )    
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new InvalidMarkException());
     }
+
+    // BEGIN android-added
+    // copied from newer version of harmony
+    /**
+     *@tests {@link java.nio.InvalidMarkException#InvalidMarkException()}
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "InvalidMarkException",
+        args = {}
+    )
+    public void test_Constructor() {
+        InvalidMarkException exception = new InvalidMarkException();
+        assertNull(exception.getMessage());
+        assertNull(exception.getLocalizedMessage());
+        assertNull(exception.getCause());
+    }
+    // END android-added
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/LongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/LongBufferTest.java
index 1529df7..c608f70 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/LongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/LongBufferTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -43,6 +42,7 @@ public class LongBufferTest extends AbstractBufferTest {
     protected LongBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = BUFFER_LENGTH;
         buf = LongBuffer.allocate(BUFFER_LENGTH);
         loadTestData1(buf);
         baseBuf = buf;
@@ -58,22 +58,28 @@ public class LongBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check LongBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify boundary value.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: LongBuffer testBuf properties is satisfy the conditions
         // specification
         LongBuffer testBuf = LongBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = LongBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -83,15 +89,13 @@ public class LongBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArrayOffset.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         long array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -108,40 +112,36 @@ public class LongBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArray.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         long array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        LongBuffer wrapped = LongBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -165,15 +165,13 @@ public class LongBufferTest extends AbstractBufferTest {
         buf.reset();
         assertEquals(buf.position(), 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         // case: buffer is full
         buf.clear();
@@ -224,15 +222,13 @@ public class LongBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.LongBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.LongBuffer.class}
+    )
     public void testCompareTo() {
         // compare to self
         assertEquals(0, buf.compareTo(buf));
@@ -255,15 +251,13 @@ public class LongBufferTest extends AbstractBufferTest {
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -295,15 +289,13 @@ public class LongBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -329,15 +321,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for long get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -355,15 +344,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer get(long[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {long[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {long[].class}
+    )
     public void testGetlongArray() {
         long array[] = new long[1];
         buf.clear();
@@ -373,14 +359,17 @@ public class LongBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i));
             assertSame(ret, buf);
         }
+
+        buf.get(new long[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
         try {
-            buf.position(buf.limit());
             buf.get((long[])null);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (NullPointerException e) {
@@ -391,15 +380,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer get(long[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {long[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {long[].class, int.class, int.class}
+    )
     public void testGetlongArrayintint() {
         buf.clear();
         long array[] = new long[buf.capacity()];
@@ -467,15 +453,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for long get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -495,27 +478,35 @@ public class LongBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that array method doesn't return null.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
-        assertNotNull(buf.array());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         LongBuffer readonly = buf.asReadOnlyBuffer();
@@ -526,44 +517,36 @@ public class LongBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity() / 2);
         assertTrue(buf.hashCode() != duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for non direct buffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for non direct buffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
-        buf.order();
         assertEquals(ByteOrder.nativeOrder(), buf.order());
     }
 
     /*
      * Class under test for java.nio.LongBuffer put(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {long.class}
+    )
     public void testPutlong() {
          buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -583,15 +566,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer put(long[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {long[].class}
+    )
     public void testPutlongArray() {
         long array[] = new long[1];
         buf.clear();
@@ -620,15 +600,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer put(long[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {long[].class, int.class, int.class}
+    )
     public void testPutlongArrayintint() {
         buf.clear();
         long array[] = new long[buf.capacity()];
@@ -701,15 +678,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer put(java.nio.LongBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.LongBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.LongBuffer.class}
+    )
     public void testPutLongBuffer() {
         LongBuffer other = LongBuffer.allocate(buf.capacity());
         try {
@@ -745,15 +719,12 @@ public class LongBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.LongBuffer put(int, long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, long.class}
+    )
     public void testPutintlong() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -775,15 +746,13 @@ public class LongBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -811,15 +780,13 @@ public class LongBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Long") >= 0 || str.indexOf("long") >= 0);
@@ -834,15 +801,12 @@ public class LongBufferTest extends AbstractBufferTest {
      * for check equal between buf2 and ling array[] 3. case for check a buf2
      * dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {long[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {long[].class}
+    )
     public void test_Wrap$L() {
         long array[] = new long[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -869,15 +833,12 @@ public class LongBufferTest extends AbstractBufferTest {
      * case for check a buf2 dependens to array[] 4. case expected
      * IndexOutOfBoundsException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {long[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {long[].class, int.class, int.class}
+    )
     public void test_Wrap$LII() {
         long array[] = new long[BUFFER_LENGTH];
         int offset = 5;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/MappedByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/MappedByteBufferTest.java
index 60c50ae..d9eefaf 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/MappedByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/MappedByteBufferTest.java
@@ -15,8 +15,16 @@
  *  limitations under the License.
  */
 
+// BEGIN android-note
+// This test was copied from a newer version of Harmony
+// END android-note
+
 package org.apache.harmony.nio.tests.java.nio;
 
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetClass;
+
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
@@ -30,6 +38,16 @@ import java.nio.channels.FileChannel.MapMode;
 
 import junit.framework.TestCase;
 
+@TestTargetClass(
+    value = MappedByteBuffer.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_FEASIBLE,
+            method = "isLoaded",
+            args = {}
+        )
+    }
+)
 public class MappedByteBufferTest extends TestCase {
 
     File tmpFile;
@@ -38,7 +56,13 @@ public class MappedByteBufferTest extends TestCase {
      * A regression test for failing to correctly set capacity of underlying
      * wrapped buffer from a mapped byte buffer.
      */
-    public void testasIntBuffer() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "A regression test for failing to correctly set capacity",
+        method = "asIntBuffer",
+        args = {}
+    )
+    public void test_asIntBuffer() throws IOException {
         // Map file
         FileInputStream fis = new FileInputStream(tmpFile);
         FileChannel fc = fis.getChannel();
@@ -65,6 +89,12 @@ public class MappedByteBufferTest extends TestCase {
     /**
      * @tests {@link java.nio.MappedByteBuffer#force()}
      */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "force",
+        args = {}
+    )
     public void test_force() throws IOException {
         // buffer was not mapped in read/write mode
         FileInputStream fileInputStream = new FileInputStream(tmpFile);
@@ -110,12 +140,18 @@ public class MappedByteBufferTest extends TestCase {
     /**
      * @tests {@link java.nio.MappedByteBuffer#load()}
      */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "load",
+        args = {}
+    )
     public void test_load() throws IOException {
         FileInputStream fileInputStream = new FileInputStream(tmpFile);
         FileChannel fileChannelRead = fileInputStream.getChannel();
         MappedByteBuffer mmbRead = fileChannelRead.map(MapMode.READ_ONLY, 0,
                 fileChannelRead.size());
-        
+
         assertEquals(mmbRead, mmbRead.load());
 
         RandomAccessFile randomFile = new RandomAccessFile(tmpFile, "rw");
@@ -124,14 +160,15 @@ public class MappedByteBufferTest extends TestCase {
                 FileChannel.MapMode.READ_WRITE, 0, fileChannelReadWrite.size());
 
         assertEquals(mmbReadWrite, mmbReadWrite.load());
-        
+
         fileChannelRead.close();
         fileChannelReadWrite.close();
     }
 
     protected void setUp() throws IOException {
         // Create temp file with 26 bytes and 5 ints
-        tmpFile = File.createTempFile("harmony", "test");  //$NON-NLS-1$//$NON-NLS-2$
+        tmpFile = new File(System.getProperty("ctsdir"), "MappedByteBufferTest");  //$NON-NLS-1$//$NON-NLS-2$
+        tmpFile.createNewFile();
         tmpFile.deleteOnExit();
         FileOutputStream fileOutputStream = new FileOutputStream(tmpFile);
         FileChannel fileChannel = fileOutputStream.getChannel();
@@ -147,4 +184,4 @@ public class MappedByteBufferTest extends TestCase {
         fileChannel.close();
         fileOutputStream.close();
     }
-}
+}
\ No newline at end of file
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyBufferExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyBufferExceptionTest.java
index 7a8dc4c..8c97ae0 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyBufferExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyBufferExceptionTest.java
@@ -15,9 +15,9 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ReadOnlyBufferException;
@@ -32,15 +32,20 @@ public class ReadOnlyBufferExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "ReadOnlyBufferException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new ReadOnlyBufferException());
@@ -49,17 +54,41 @@ public class ReadOnlyBufferExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "ReadOnlyBufferException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new ReadOnlyBufferException());
     }
+
+    // BEGIN android-added
+    // copied from newer version of harmony
+    /**
+     *@tests {@link java.nio.ReadOnlyBufferException#ReadOnlyBufferException()}
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "ReadOnlyBufferException",
+        args = {}
+    )
+    public void test_Constructor() {
+        ReadOnlyBufferException exception = new ReadOnlyBufferException();
+        assertNull(exception.getMessage());
+        assertNull(exception.getLocalizedMessage());
+        assertNull(exception.getCause());
+    }
+    // END android-added
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyCharBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyCharBufferTest.java
index 69ae84c..e5d3573 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyCharBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyCharBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.CharBuffer;
@@ -28,7 +27,6 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
-        loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
         baseBuf = buf;
     }
@@ -38,41 +36,33 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
         baseBuf = null;
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that isReadOnly returns true for read only " +
-            "CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that isReadOnly returns true for read only CharBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that hasArray returns false for read only " +
-            "CharBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that hasArray returns false for read only CharBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -80,44 +70,38 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
         } catch (ReadOnlyBufferException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         CharBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -126,15 +110,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {char.class}
+    )
     public void testPutchar() {
         try {
             buf.put((char) 0);
@@ -143,15 +125,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException and NullPointerException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException and NullPointerException.",
+        method = "put",
+        args = {char[].class}
+    )
     public void testPutcharArray() {
         char array[] = new char[1];
         try {
@@ -167,15 +147,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {char[].class, int.class, int.class}
+    )
     public void testPutcharArrayintint() {
         char array[] = new char[1];
         try {
@@ -203,15 +181,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testPutCharBuffer() {
         CharBuffer other = CharBuffer.allocate(1);
         try {
@@ -233,15 +209,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, char.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, char.class}
+    )
     public void testPutintchar() {
         try {
             buf.put(0, (char) 0);
@@ -256,15 +230,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.lang.String.class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.lang.String.class, int.class, int.class}
+    )
     public void testPutStringintint() {
         buf.clear();
         String str = String.valueOf(new char[buf.capacity()]);
@@ -294,15 +266,13 @@ public class ReadOnlyCharBufferTest extends CharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.lang.String.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.lang.String.class}
+    )
     public void testPutString() {
         String str = " ";
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDirectByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDirectByteBufferTest.java
index d1a5265..e51f013 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDirectByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDirectByteBufferTest.java
@@ -16,9 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -33,41 +32,25 @@ public class ReadOnlyDirectByteBufferTest extends DirectByteBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only ByteBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that hasArray method returns false.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
-    public void testHasArray() {
-        assertFalse(buf.hasArray());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
-        super.readOnlyHashCode();
+        super.readOnlyHashCode(true);
     }
 
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDoubleBufferTest.java
index 46522c2..056c2e2 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyDoubleBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.DoubleBuffer;
@@ -35,39 +34,33 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only DoubleBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only DoubleBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that hasArray returns false value.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that hasArray returns false value.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -75,44 +68,38 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
         } catch (ReadOnlyBufferException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         DoubleBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -121,15 +108,13 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {double.class}
+    )
     public void testPutdouble() {
         try {
             buf.put(0);
@@ -138,15 +123,13 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {double[].class}
+    )
     public void testPutdoubleArray() {
         double array[] = new double[1];
         try {
@@ -162,15 +145,13 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {double[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {double[].class, int.class, int.class}
+    )
     public void testPutdoubleArrayintint() {
         double array[] = new double[1];
         try {
@@ -198,15 +179,13 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.DoubleBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.DoubleBuffer.class}
+    )
     public void testPutDoubleBuffer() {
         DoubleBuffer other = DoubleBuffer.allocate(1);
         try {
@@ -228,15 +207,13 @@ public class ReadOnlyDoubleBufferTest extends DoubleBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, double.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, double.class}
+    )
     public void testPutintdouble() {
         try {
             buf.put(0, (double) 0);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyFloatBufferTest.java
index 1edcecb..6bb572d 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyFloatBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.FloatBuffer;
@@ -34,40 +33,33 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only FloatBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that hasArray returns false for Read Only " +
-            "FloatBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that hasArray returns false for Read Only FloatBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -76,45 +68,39 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         FloatBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -123,15 +109,13 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {float.class}
+    )
     public void testPutfloat() {
         try {
             buf.put(0);
@@ -140,15 +124,13 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {float[].class}
+    )
     public void testPutfloatArray() {
         float array[] = new float[1];
         try {
@@ -164,15 +146,13 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {float[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {float[].class, int.class, int.class}
+    )
     public void testPutfloatArrayintint() {
         float array[] = new float[1];
         try {
@@ -200,15 +180,13 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.FloatBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.FloatBuffer.class}
+    )
     public void testPutFloatBuffer() {
         FloatBuffer other = FloatBuffer.allocate(1);
         try {
@@ -230,15 +208,13 @@ public class ReadOnlyFloatBufferTest extends FloatBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, float.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, float.class}
+    )
     public void testPutintfloat() {
         try {
             buf.put(0, (float) 0);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapByteBufferTest.java
index 7c0f093..a0a04ff 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapByteBufferTest.java
@@ -16,9 +16,10 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import java.nio.ReadOnlyBufferException;
+
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -33,40 +34,70 @@ public class ReadOnlyHeapByteBufferTest extends HeapByteBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
+    public void testArray() {
+        try {
+            buf.array();
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
+    public void testArrayOffset() {
+        try {
+            buf.arrayOffset();
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only ByteBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies false returned value.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies false returned value.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
+        try {
+            buf.array();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
-        super.readOnlyHashCode();    
+        super.readOnlyHashCode(false);    
     }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapCharBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapCharBufferTest.java
index e5a437d..610e498 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapCharBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapCharBufferTest.java
@@ -16,22 +16,13 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
-import java.nio.CharBuffer;
-
 @TestTargetClass(java.nio.CharBuffer.class)
 public class ReadOnlyHeapCharBufferTest extends ReadOnlyCharBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
-        buf = CharBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapDoubleBufferTest.java
index 8848e21..ea3b647 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapDoubleBufferTest.java
@@ -15,22 +15,13 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
-import java.nio.DoubleBuffer;
-
 @TestTargetClass(java.nio.DoubleBuffer.class)
 public class ReadOnlyHeapDoubleBufferTest extends ReadOnlyDoubleBufferTest {
     
     protected void setUp() throws Exception {
         super.setUp();
-        buf = DoubleBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapFloatBufferTest.java
index 6cda42c..8439b88 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapFloatBufferTest.java
@@ -15,22 +15,13 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
-import dalvik.annotation.TestLevel;
-
-import java.nio.FloatBuffer;
 
 @TestTargetClass(java.nio.FloatBuffer.class)
 public class ReadOnlyHeapFloatBufferTest extends ReadOnlyFloatBufferTest {
     
     protected void setUp() throws Exception {
         super.setUp();
-        buf = FloatBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapIntBufferTest.java
index 098b9ab..7ce3057 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapIntBufferTest.java
@@ -15,22 +15,13 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
-import java.nio.IntBuffer;
-
 @TestTargetClass(java.nio.IntBuffer.class)
 public class ReadOnlyHeapIntBufferTest extends ReadOnlyIntBufferTest {
     
     protected void setUp() throws Exception {
         super.setUp();
-        buf = IntBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapLongBufferTest.java
index 6e14615..e3cbbbc 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapLongBufferTest.java
@@ -15,22 +15,13 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
-import java.nio.LongBuffer;
-
 @TestTargetClass(java.nio.LongBuffer.class)
 public class ReadOnlyHeapLongBufferTest extends ReadOnlyLongBufferTest{
     
     protected void setUp() throws Exception {
         super.setUp();
-        buf = LongBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapShortBufferTest.java
index 4d38aa7..77d0d0b 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyHeapShortBufferTest.java
@@ -15,22 +15,13 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
-import dalvik.annotation.TestLevel;
-
-import java.nio.ShortBuffer;
 
 @TestTargetClass(java.nio.ShortBuffer.class)
 public class ReadOnlyHeapShortBufferTest extends ReadOnlyShortBufferTest {
     
     protected void setUp() throws Exception {
         super.setUp();
-        buf = ShortBuffer.allocate(BUFFER_LENGTH);
-        super.loadTestData1(buf);
-        buf = buf.asReadOnlyBuffer();
-        baseBuf = buf;
     }
 
     protected void tearDown() throws Exception {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyIntBufferTest.java
index 6c97ae2..3da8d2f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyIntBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.IntBuffer;
@@ -34,40 +33,33 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only IntBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method returns false for read only " +
-            "IntBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method returns false for read only IntBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -76,45 +68,39 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         IntBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -123,15 +109,13 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class}
+    )
     public void testPutint() {
         try {
             buf.put(0);
@@ -140,15 +124,13 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int[].class}
+    )
     public void testPutintArray() {
         int array[] = new int[1];
         try {
@@ -164,15 +146,13 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int[].class, int.class, int.class}
+    )
     public void testPutintArrayintint() {
         int array[] = new int[1];
         try {
@@ -200,15 +180,13 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.IntBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.IntBuffer.class}
+    )
     public void testPutIntBuffer() {
         IntBuffer other = IntBuffer.allocate(1);
         try {
@@ -230,15 +208,13 @@ public class ReadOnlyIntBufferTest extends IntBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, int.class}
+    )
     public void testPutintint() {
         try {
             buf.put(0, (int) 0);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyLongBufferTest.java
index b299d06..5337b3c 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyLongBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.LongBuffer;
@@ -34,40 +33,33 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only LongBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that hasArray method returns false for read only " +
-            "LongBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that hasArray method returns false for read only LongBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -76,45 +68,39 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         LongBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -123,15 +109,13 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {long.class}
+    )
     public void testPutlong() {
         try {
             buf.put(0);
@@ -140,15 +124,13 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {long[].class}
+    )
     public void testPutlongArray() {
         long array[] = new long[1];
         try {
@@ -164,15 +146,13 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {long[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {long[].class, int.class, int.class}
+    )
     public void testPutlongArrayintint() {
         long array[] = new long[1];
         try {
@@ -200,15 +180,13 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.LongBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.LongBuffer.class}
+    )
     public void testPutLongBuffer() {
         LongBuffer other = LongBuffer.allocate(1);
         try {
@@ -230,15 +208,13 @@ public class ReadOnlyLongBufferTest extends LongBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, long.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, long.class}
+    )
     public void testPutintlong() {
         try {
             buf.put(0, (long) 0);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyShortBufferTest.java
index 13c2558..a5aaa90 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyShortBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ReadOnlyBufferException;
@@ -34,39 +33,33 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only ShortBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for read only ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for read only ShortBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -75,45 +68,39 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         ShortBuffer duplicate = buf.duplicate();
         assertEquals(buf.hashCode(), duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         try {
             buf.arrayOffset();
-            fail("Should throw Exception"); //$NON-NLS-1$
-        } catch (UnsupportedOperationException e) {
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
             //expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         try {
             buf.compact();
@@ -122,15 +109,13 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {short.class}
+    )
     public void testPutshort() {
         try {
             buf.put((short)0);
@@ -139,15 +124,13 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short[].class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {short[].class}
+    )
     public void testPutshortArray() {
         short array[] = new short[1];
         try {
@@ -163,15 +146,13 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {short[].class, int.class, int.class}
+    )
     public void testPutshortArrayintint() {
         short array[] = new short[1];
         try {
@@ -199,15 +180,13 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.ShortBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.ShortBuffer.class}
+    )
     public void testPutShortBuffer() {
         ShortBuffer other = ShortBuffer.allocate(1);
         try {
@@ -229,15 +208,13 @@ public class ReadOnlyShortBufferTest extends ShortBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, short.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, short.class}
+    )
     public void testPutintshort() {
         try {
             buf.put(0, (short) 0);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedByteBufferTest.java
index b5e1ae0..5986d96 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedByteBufferTest.java
@@ -16,9 +16,10 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
+import java.nio.ReadOnlyBufferException;
+
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -33,42 +34,71 @@ public class ReadOnlyWrappedByteBufferTest extends WrappedByteBufferTest {
     protected void tearDown() throws Exception {
         super.tearDown();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isReadOnly method for read only wrapped " +
-            "ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
+    public void testArray() {
+        try {
+            buf.array();
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
+    public void testArrayOffset() {
+        try {
+            buf.arrayOffset();
+            fail("Should throw ReadOnlyBufferException"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isReadOnly method for read only wrapped ByteBuffer.",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertTrue(buf.isReadOnly());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for read only wrapped ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for read only wrapped ByteBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertFalse(buf.hasArray());
+        try {
+            buf.array();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (ReadOnlyBufferException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
-        super.readOnlyHashCode();
+        super.readOnlyHashCode(false);
     }
 
 
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedCharBufferTest1.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedCharBufferTest1.java
index 481dd9c..259e3d9 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedCharBufferTest1.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedCharBufferTest1.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.CharBuffer;
@@ -28,6 +25,7 @@ public class ReadOnlyWrappedCharBufferTest1 extends ReadOnlyCharBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = CharBuffer.wrap(new char[BUFFER_LENGTH]);
         super.loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedDoubleBufferTest.java
index bdd6066..21951cf 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedDoubleBufferTest.java
@@ -15,9 +15,6 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.DoubleBuffer;
@@ -27,6 +24,7 @@ public class ReadOnlyWrappedDoubleBufferTest extends ReadOnlyDoubleBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = DoubleBuffer.wrap(new double[BUFFER_LENGTH]);
         super.loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedFloatBufferTest.java
index 7e4d28b..cfbca11 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedFloatBufferTest.java
@@ -15,9 +15,6 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.FloatBuffer;
@@ -27,6 +24,7 @@ public class ReadOnlyWrappedFloatBufferTest extends ReadOnlyFloatBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = FloatBuffer.wrap(new float[BUFFER_LENGTH]);
         super.loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedIntBufferTest.java
index 3c560bb..a9210d2 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedIntBufferTest.java
@@ -15,9 +15,6 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.IntBuffer;
@@ -27,8 +24,9 @@ public class ReadOnlyWrappedIntBufferTest extends ReadOnlyIntBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = IntBuffer.wrap(new int[BUFFER_LENGTH]);
-        super.loadTestData1(buf);
+        loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
         baseBuf = buf;
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedLongBufferTest.java
index b23001a..392d9c5 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedLongBufferTest.java
@@ -15,9 +15,6 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.LongBuffer;
@@ -27,8 +24,9 @@ public class ReadOnlyWrappedLongBufferTest extends ReadOnlyLongBufferTest{
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = LongBuffer.wrap(new long[BUFFER_LENGTH]);
-        super.loadTestData1(buf);
+        loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
         baseBuf = buf;
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedShortBufferTest.java
index 97f1703..32e5c29 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ReadOnlyWrappedShortBufferTest.java
@@ -15,9 +15,6 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ShortBuffer;
@@ -27,8 +24,9 @@ public class ReadOnlyWrappedShortBufferTest extends ReadOnlyShortBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = ShortBuffer.wrap(new short[BUFFER_LENGTH]);
-        super.loadTestData1(buf);
+        loadTestData1(buf);
         buf = buf.asReadOnlyBuffer();
         baseBuf = buf;
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ShortBufferTest.java
index 997865a..13af578 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/ShortBufferTest.java
@@ -17,9 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -42,6 +41,7 @@ public class ShortBufferTest extends AbstractBufferTest {
     protected ShortBuffer buf;
 
     protected void setUp() throws Exception {
+        capacity = BUFFER_LENGTH;
         buf = ShortBuffer.allocate(BUFFER_LENGTH);
         loadTestData1(buf);
         baseBuf = buf;
@@ -57,22 +57,28 @@ public class ShortBufferTest extends AbstractBufferTest {
      * following usecases: 1. case for check ShortBuffer testBuf properties 2.
      * case expected IllegalArgumentException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify boundary value.",
-      targets = {
-        @TestTarget(
-          methodName = "allocate",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "allocate",
+        args = {int.class}
+    )
     public void test_AllocateI() {
         // case: ShortBuffer testBuf properties is satisfy the conditions
         // specification
         ShortBuffer testBuf = ShortBuffer.allocate(20);
-        assertEquals(testBuf.position(), 0);
-        assertEquals(testBuf.limit(), testBuf.capacity());
-        assertEquals(testBuf.arrayOffset(), 0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(20, testBuf.limit());
+        assertEquals(20, testBuf.capacity());
+
+        testBuf = ShortBuffer.allocate(0);
+        assertEquals(0, testBuf.position());
+        assertNotNull(testBuf.array());
+        assertEquals(0, testBuf.arrayOffset());
+        assertEquals(0, testBuf.limit());
+        assertEquals(0, testBuf.capacity());
 
         // case: expected IllegalArgumentException
         try {
@@ -82,15 +88,13 @@ public class ShortBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArrayOffset.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         short array[] = buf.array();
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
@@ -107,40 +111,36 @@ public class ShortBufferTest extends AbstractBufferTest {
         loadTestData2(buf);
         assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "The same test as testArray.",
-      targets = {
-        @TestTarget(
-          methodName = "arrayOffset",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "arrayOffset",
+        args = {}
+    )
     public void testArrayOffset() {
         short array[] = buf.array();
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData1(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
-
-        loadTestData2(array, buf.arrayOffset(), buf.capacity());
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        for(int i = 0; i < buf.capacity(); i++) {
+            array[i] = (short) i;
+        }
+        int offset = buf.arrayOffset();
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData1(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        ShortBuffer wrapped = ShortBuffer.wrap(array, 3, array.length - 3);
+        
+        loadTestData1(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
 
-        loadTestData2(buf);
-        assertContentEquals(buf, array, buf.arrayOffset(), buf.capacity());
+        loadTestData2(array, wrapped.arrayOffset(), wrapped.capacity());
+        assertContentEquals(buf, array, offset, buf.capacity());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "asReadOnlyBuffer",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "asReadOnlyBuffer",
+        args = {}
+    )
     public void testAsReadOnlyBuffer() {
         buf.clear();
         buf.mark();
@@ -164,15 +164,13 @@ public class ShortBufferTest extends AbstractBufferTest {
         buf.reset();
         assertEquals(buf.position(), 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compact",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compact",
+        args = {}
+    )
     public void testCompact() {
         // case: buffer is full
         buf.clear();
@@ -223,15 +221,13 @@ public class ShortBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "compareTo",
-          methodArgs = {java.nio.ShortBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "compareTo",
+        args = {java.nio.ShortBuffer.class}
+    )
     public void testCompareTo() {
         // compare to self
         assertEquals(0, buf.compareTo(buf));
@@ -254,15 +250,13 @@ public class ShortBufferTest extends AbstractBufferTest {
         assertTrue(buf.compareTo(other) > 0);
         assertTrue(other.compareTo(buf) < 0);
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "duplicate",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "duplicate",
+        args = {}
+    )
     public void testDuplicate() {
         buf.clear();
         buf.mark();
@@ -294,15 +288,13 @@ public class ShortBufferTest extends AbstractBufferTest {
             assertContentEquals(buf, duplicate);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "equals",
-          methodArgs = {java.lang.Object.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "equals",
+        args = {java.lang.Object.class}
+    )
     public void testEquals() {
         // equal to self
         assertTrue(buf.equals(buf));
@@ -328,15 +320,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for short get()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {}
+    )
     public void testGet() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -354,15 +343,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ShortBuffer get(short[])
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {short[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {short[].class}
+    )
     public void testGetshortArray() {
         short array[] = new short[1];
         buf.clear();
@@ -372,26 +358,33 @@ public class ShortBufferTest extends AbstractBufferTest {
             assertEquals(array[0], buf.get(i));
             assertSame(ret, buf);
         }
+
+        buf.get(new short[0]);
+
         try {
             buf.get(array);
             fail("Should throw Exception"); //$NON-NLS-1$
         } catch (BufferUnderflowException e) {
             // expected
         }
+
+        try {
+            buf.get((short[])null);
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (NullPointerException e) {
+            // expected
+        }
     }
 
     /*
      * Class under test for java.nio.ShortBuffer get(short[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {short[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {short[].class, int.class, int.class}
+    )
     public void testGetshortArrayintint() {
         buf.clear();
         short array[] = new short[buf.capacity()];
@@ -453,15 +446,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for short get(int)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "get",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "get",
+        args = {int.class}
+    )
     public void testGetint() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -481,27 +471,35 @@ public class ShortBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that array method doesn't return null.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
-        assertNotNull(buf.array());
-    }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "hashCode",
-          methodArgs = {}
-        )
-    })
+        if (buf.hasArray()) {
+            assertNotNull(buf.array());
+        } else {
+            try {
+                buf.array();
+                fail("Should throw Exception"); //$NON-NLS-1$
+            } catch (UnsupportedOperationException e) {
+                // expected
+                // Note:can not tell when to catch 
+                // UnsupportedOperationException or
+                // ReadOnlyBufferException, so catch all.
+            }
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "hashCode",
+        args = {}
+    )
     public void testHashCode() {
         buf.clear();
         ShortBuffer readonly = buf.asReadOnlyBuffer();
@@ -512,44 +510,36 @@ public class ShortBufferTest extends AbstractBufferTest {
         duplicate.position(buf.capacity() / 2);
         assertTrue(buf.hashCode() != duplicate.hashCode());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies isDirect method for non direct ShortBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for non direct ShortBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "order",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "order",
+        args = {}
+    )
     public void testOrder() {
-        buf.order();
         assertEquals(ByteOrder.nativeOrder(), buf.order());
     }
 
     /*
      * Class under test for java.nio.ShortBuffer put(short)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {short.class}
+    )
     public void testPutshort() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -569,15 +559,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ShortBuffer put(short[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {short[].class}
+    )
     public void testPutshortArray() {
         short array[] = new short[1];
         buf.clear();
@@ -606,15 +593,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ShortBuffer put(short[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {short[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {short[].class, int.class, int.class}
+    )
     public void testPutshortArrayintint() {
         buf.clear();
         short array[] = new short[buf.capacity()];
@@ -681,15 +665,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ShortBuffer put(java.nio.ShortBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {java.nio.ShortBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {java.nio.ShortBuffer.class}
+    )
     public void testPutShortBuffer() {
         ShortBuffer other = ShortBuffer.allocate(buf.capacity());
         try {
@@ -725,15 +706,12 @@ public class ShortBufferTest extends AbstractBufferTest {
     /*
      * Class under test for java.nio.ShortBuffer put(int, short)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify ReadOnlyBufferException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {int.class, short.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify ReadOnlyBufferException.",
+        method = "put",
+        args = {int.class, short.class}
+    )
     public void testPutintshort() {
         buf.clear();
         for (int i = 0; i < buf.capacity(); i++) {
@@ -755,15 +733,13 @@ public class ShortBufferTest extends AbstractBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "slice",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "slice",
+        args = {}
+    )
     public void testSlice() {
         assertTrue(buf.capacity() > 5);
         buf.position(1);
@@ -791,15 +767,13 @@ public class ShortBufferTest extends AbstractBufferTest {
             assertEquals(slice.get(1), 500);
         }
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void testToString() {
         String str = buf.toString();
         assertTrue(str.indexOf("Short") >= 0 || str.indexOf("short") >= 0);
@@ -814,15 +788,12 @@ public class ShortBufferTest extends AbstractBufferTest {
      * for check equal between buf2 and short array[] 3. case for check a buf2
      * dependens to array[]
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {short[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {short[].class}
+    )
     public void test_Wrap$S() {
         short array[] = new short[BUFFER_LENGTH];
         loadTestData1(array, 0, BUFFER_LENGTH);
@@ -849,15 +820,12 @@ public class ShortBufferTest extends AbstractBufferTest {
      * case for check a buf2 dependens to array[] 4. case expected
      * IndexOutOfBoundsException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {short[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {short[].class, int.class, int.class}
+    )
     public void test_Wrap$SII() {
         short array[] = new short[BUFFER_LENGTH];
         int offset = 5;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceDirectByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceDirectByteBufferTest.java
index f6d611e..8b94e3e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceDirectByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceDirectByteBufferTest.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -26,6 +23,7 @@ public class SliceDirectByteBufferTest extends DirectByteBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH - 2;
         buf.position(1).limit(BUFFER_LENGTH-1);
         buf = buf.slice();
         baseBuf = buf;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceHeapByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceHeapByteBufferTest.java
index 2b4a7f5..aafe47f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceHeapByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceHeapByteBufferTest.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -26,6 +23,7 @@ public class SliceHeapByteBufferTest extends HeapByteBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH - 2;
         buf.position(1).limit(BUFFER_LENGTH-1);
         buf = buf.slice();
         baseBuf = buf;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceWrappedByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceWrappedByteBufferTest.java
index 84f37e7..d348916 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceWrappedByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/SliceWrappedByteBufferTest.java
@@ -16,9 +16,6 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
 import dalvik.annotation.TestTargetClass;
 
 @TestTargetClass(java.nio.ByteBuffer.class)
@@ -26,6 +23,7 @@ public class SliceWrappedByteBufferTest extends WrappedByteBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH - 2;
         buf.position(1).limit(BUFFER_LENGTH-1);
         buf = buf.slice();
         baseBuf = buf;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedByteBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedByteBufferTest.java
index 78b96fc..94c8418 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedByteBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedByteBufferTest.java
@@ -16,9 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ByteBuffer;
@@ -28,6 +27,7 @@ public class WrappedByteBufferTest extends ByteBufferTest {
     
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = ByteBuffer.wrap(new byte[BUFFER_LENGTH]);
         baseBuf = buf;
     }
@@ -42,15 +42,12 @@ public class WrappedByteBufferTest extends ByteBufferTest {
      * @tests java.nio.ByteBuffer#allocate(byte[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IndexOutOfBoundsException, NullPointerException.",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {byte[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException, NullPointerException.",
+        method = "wrap",
+        args = {byte[].class, int.class, int.class}
+    )
     public void testWrappedByteBuffer_IllegalArg() {
         byte array[] = new byte[BUFFER_LENGTH];
         try {
@@ -96,39 +93,34 @@ public class WrappedByteBufferTest extends ByteBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies isDirect method for non direct ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "isDirect",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies isDirect method for non direct ByteBuffer.",
+        method = "isDirect",
+        args = {}
+    )
     public void testIsDirect() {
         assertFalse(buf.isDirect());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies hasArray method for wrapped ByteBuffer.",
-      targets = {
-        @TestTarget(
-          methodName = "hasArray",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies hasArray method for wrapped ByteBuffer.",
+        method = "hasArray",
+        args = {}
+    )
     public void testHasArray() {
         assertTrue(buf.hasArray());
+        assertNotNull(buf.array());
     }
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isReadOnly",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isReadOnly",
+        args = {}
+    )
     public void testIsReadOnly() {
         assertFalse(buf.isReadOnly());
     }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest1.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest1.java
index 3187746..ff48762 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest1.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest1.java
@@ -16,9 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.CharBuffer;
@@ -28,6 +27,7 @@ public class WrappedCharBufferTest1 extends CharBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = CharBuffer.wrap(new char[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -43,15 +43,12 @@ public class WrappedCharBufferTest1 extends CharBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-          level = TestLevel.PARTIAL_OK,
-          purpose = "Verifies IndexOutOfBoundsException, NullPointerException.",
-          targets = {
-            @TestTarget(
-              methodName = "wrap",
-              methodArgs = {java.lang.CharSequence.class, int.class, int.class}
-            )
-        })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException, NullPointerException.",
+        method = "wrap",
+        args = {java.lang.CharSequence.class, int.class, int.class}
+    )
     public void testWrappedCharBuffer_IllegalArg() {
         char array[] = new char[BUFFER_LENGTH];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest2.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest2.java
index a009a41..e3a51c8 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest2.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedCharBufferTest2.java
@@ -16,9 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.BufferOverflowException;
@@ -31,6 +30,7 @@ public class WrappedCharBufferTest2 extends ReadOnlyCharBufferTest {
 
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = TEST_STRING.length();
         buf = CharBuffer.wrap(TEST_STRING);
         baseBuf = buf;
     }
@@ -40,15 +40,13 @@ public class WrappedCharBufferTest2 extends ReadOnlyCharBufferTest {
         baseBuf = null;
         buf = null;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies NullPointerException, IndexOutOfBoundsException.",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {java.lang.CharSequence.class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, IndexOutOfBoundsException.",
+        method = "wrap",
+        args = {java.lang.CharSequence.class, int.class, int.class}
+    )
     public void testWrappedCharSequence_IllegalArg() {
         String str = TEST_STRING;
         try {
@@ -82,15 +80,13 @@ public class WrappedCharBufferTest2 extends ReadOnlyCharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedOperationException.",
-      targets = {
-        @TestTarget(
-          methodName = "array",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedOperationException for CharSequenceAdapter.",
+        method = "array",
+        args = {}
+    )
     public void testArray() {
         try {
             buf.array();
@@ -98,16 +94,27 @@ public class WrappedCharBufferTest2 extends ReadOnlyCharBufferTest {
         } catch (UnsupportedOperationException e) {
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException, NullPointerException, " +
-            "BufferOverflowException, IndexOutOfBoundsException.",
-      targets = {
-        @TestTarget(
-          methodName = "put",
-          methodArgs = {char[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedOperationException.",
+        method = "arrayOffset",
+        args = {}
+    )
+    public void testArrayOffset() {
+        try {
+            buf.arrayOffset();
+            fail("Should throw Exception"); //$NON-NLS-1$
+        } catch (UnsupportedOperationException e) {
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException, NullPointerException, BufferOverflowException, IndexOutOfBoundsException.",
+        method = "put",
+        args = {char[].class, int.class, int.class}
+    )
     public void testPutcharArrayintint() {
         char array[] = new char[1];
         try {
@@ -135,16 +142,13 @@ public class WrappedCharBufferTest2 extends ReadOnlyCharBufferTest {
             // expected
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ReadOnlyBufferException, NullPointerException, " +
-            "IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.CharBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ReadOnlyBufferException, NullPointerException, IllegalArgumentException.",
+        method = "read",
+        args = {java.nio.CharBuffer.class}
+    )
     public void testPutCharBuffer() {
         CharBuffer other = CharBuffer.allocate(1);
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedDoubleBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedDoubleBufferTest.java
index 4fff361..4ea5c84 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedDoubleBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedDoubleBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.DoubleBuffer;
@@ -26,6 +25,7 @@ import java.nio.DoubleBuffer;
 public class WrappedDoubleBufferTest extends DoubleBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = DoubleBuffer.wrap(new double[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -41,15 +41,12 @@ public class WrappedDoubleBufferTest extends DoubleBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {double[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {double[].class, int.class, int.class}
+    )
     public void testWrappedDoubleuffer_IllegalArg() {
         double array[] = new double[20];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedFloatBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedFloatBufferTest.java
index a309868..71f84a9 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedFloatBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedFloatBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.FloatBuffer;
@@ -26,6 +25,7 @@ import java.nio.FloatBuffer;
 public class WrappedFloatBufferTest extends FloatBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = FloatBuffer.wrap(new float[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -41,15 +41,12 @@ public class WrappedFloatBufferTest extends FloatBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {float[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {float[].class, int.class, int.class}
+    )
     public void testWrappedFloatBuffer_IllegalArg() {
         float array[] = new float[20];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedIntBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedIntBufferTest.java
index cccb633..3041de7 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedIntBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedIntBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.IntBuffer;
@@ -26,6 +25,7 @@ import java.nio.IntBuffer;
 public class WrappedIntBufferTest extends IntBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = IntBuffer.wrap(new int[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -41,15 +41,12 @@ public class WrappedIntBufferTest extends IntBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {int[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {int[].class, int.class, int.class}
+    )
     public void testWrappedIntBuffer_IllegalArg() {
         int array[] = new int[20];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedLongBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedLongBufferTest.java
index 52e8eae..552a1e3 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedLongBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedLongBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.LongBuffer;
@@ -26,6 +25,7 @@ import java.nio.LongBuffer;
 public class WrappedLongBufferTest extends LongBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = LongBuffer.wrap(new long[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -41,15 +41,12 @@ public class WrappedLongBufferTest extends LongBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {long[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {long[].class, int.class, int.class}
+    )
     public void testWrappedLongBuffer_IllegalArg() {
         long array[] = new long[20];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedShortBufferTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedShortBufferTest.java
index 36794b5..9917ae0 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedShortBufferTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/WrappedShortBufferTest.java
@@ -15,9 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio;
 
-import dalvik.annotation.TestInfo;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.ShortBuffer;
@@ -26,6 +25,7 @@ import java.nio.ShortBuffer;
 public class WrappedShortBufferTest extends ShortBufferTest {
     protected void setUp() throws Exception {
         super.setUp();
+        capacity = BUFFER_LENGTH;
         buf = ShortBuffer.wrap(new short[BUFFER_LENGTH]);
         loadTestData1(buf);
         baseBuf = buf;
@@ -41,15 +41,12 @@ public class WrappedShortBufferTest extends ShortBufferTest {
      * @tests java.nio.CharBuffer#allocate(char[],int,int)
      * 
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wrap",
-          methodArgs = {short[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "wrap",
+        args = {short[].class, int.class, int.class}
+    )
     public void testWrappedShortBuffer_IllegalArg() {
         short array[] = new short[20];
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AllTests.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AllTests.java
index 0ecd41c..8031c5f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AllTests.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AllTests.java
@@ -26,7 +26,7 @@ public class AllTests {
     }
 
     public static Test suite() {
-        TestSuite suite = new TestSuite(AllTests.class.getName());
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite(AllTests.class.getName());
         //$JUnit-BEGIN$
         suite.addTestSuite(AlreadyConnectedExceptionTest.class);
         suite.addTestSuite(AsynchronousCloseExceptionTest.class);
@@ -37,7 +37,6 @@ public class AllTests {
         suite.addTestSuite(ClosedSelectorExceptionTest.class);
         suite.addTestSuite(ConnectionPendingExceptionTest.class);
         suite.addTestSuite(DatagramChannelTest.class); 
-        suite.addTestSuite(FileChannelLockingTest.class);
         suite.addTestSuite(FileChannelTest.class);
         suite.addTestSuite(FileLockInterruptionExceptionTest.class);
         suite.addTestSuite(FileLockTest.class);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AlreadyConnectedExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AlreadyConnectedExceptionTest.java
index c236659..6767713 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AlreadyConnectedExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AlreadyConnectedExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class AlreadyConnectedExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-          level = TestLevel.COMPLETE,
-          purpose = "Verifies serialization/deserialization compatibility.",
-          targets = {
-            @TestTarget(
-              methodName = "!SerializationSelf",
-              methodArgs = {}
-            )
-        })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "AlreadyConnectedException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new AlreadyConnectedException());
@@ -52,15 +57,20 @@ public class AlreadyConnectedExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "AlreadyConnectedException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new AlreadyConnectedException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AsynchronousCloseExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AsynchronousCloseExceptionTest.java
index 7a8c426..b9f392d 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AsynchronousCloseExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/AsynchronousCloseExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class AsynchronousCloseExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "AsynchronousCloseException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new AsynchronousCloseException());
@@ -52,15 +57,20 @@ public class AsynchronousCloseExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "AsynchronousCloseException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new AsynchronousCloseException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/CancelledKeyExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/CancelledKeyExceptionTest.java
index 8e398a9..a8edce4 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/CancelledKeyExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/CancelledKeyExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class CancelledKeyExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "CancelledKeyException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new CancelledKeyException());
@@ -52,15 +57,20 @@ public class CancelledKeyExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "CancelledKeyException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new CancelledKeyException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ChannelsTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ChannelsTest.java
index a791c20..46e9f4c 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ChannelsTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ChannelsTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -117,15 +117,12 @@ public class ChannelsTest extends TestCase {
     }
 
     // test if new Channel to input is null
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.InputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.InputStream.class}
+    )
     public void testNewChannelInputStream_InputNull() throws IOException {
         ByteBuffer byteBuf = ByteBuffer.allocate(this.testNum);
         this.fins = null;
@@ -142,15 +139,12 @@ public class ChannelsTest extends TestCase {
     }
 
     // test if buffer to read is null
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.InputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.InputStream.class}
+    )
     public void testNewChannelInputStream_BufferNull() throws IOException {
         ByteBuffer byteBuf = ByteBuffer.allocate(this.testNum);
         int readres = this.testNum;
@@ -176,15 +170,12 @@ public class ChannelsTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.Channels.NewChannel'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.InputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.InputStream.class}
+    )
     public void testNewChannelInputStream() throws IOException {
         int bufSize = 10;
         int readres = 0;
@@ -213,15 +204,12 @@ public class ChannelsTest extends TestCase {
     }
 
     // test if fout to change is null
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.OutputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.OutputStream.class}
+    )
     public void testNewChannelOutputStream_inputNull() throws IOException {
         int writeres = this.testNum;
         ByteBuffer writebuf = ByteBuffer.allocate(this.writebufSize);
@@ -242,15 +230,12 @@ public class ChannelsTest extends TestCase {
     }
 
     // test if write buf is null
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.OutputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.OutputStream.class}
+    )
     public void testNewChannelOutputStream_BufNull() throws IOException {
         int writeres = this.testNum;
         ByteBuffer writebuf = null;
@@ -273,15 +258,12 @@ public class ChannelsTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.Channels.NewChannel(OutputStream)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newChannel",
-          methodArgs = {java.io.OutputStream.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newChannel",
+        args = {java.io.OutputStream.class}
+    )
     public void testNewChannelOutputStream() throws IOException {
         int writeNum = 0;
         ByteBuffer writebuf = ByteBuffer.allocateDirect(this.writebufSize);
@@ -326,15 +308,13 @@ public class ChannelsTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newInputStream",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newInputStream",
+        args = {java.nio.channels.ReadableByteChannel.class}
+    )
     public void testNewInputStreamReadableByteChannel_InputNull()
             throws Exception {
         byte[] readbuf = new byte[this.testNum];
@@ -360,16 +340,13 @@ public class ChannelsTest extends TestCase {
         }
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify IllegalBlockingModeException for read methods " +
-            "according to the specification.",
-      targets = {
-        @TestTarget(
-          methodName = "newInputStream",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newInputStream",
+        args = {java.nio.channels.ReadableByteChannel.class}
+    )
     public void testNewInputStreamReadableByteChannel() throws Exception {
         ByteBuffer readbcbuf = ByteBuffer.allocateDirect(this.testNum);
         byte[] readbuf = new byte[this.testNum];
@@ -386,6 +363,20 @@ public class ChannelsTest extends TestCase {
         assertEquals(this.fins.available(), this.fileSize - this.testNum * 2);
         testins.read(readbuf);
         assertEquals(this.fins.available(), this.fileSize - this.testNum * 3);
+
+        assertFalse(testins.markSupported());
+        try {
+            testins.mark(10);
+        } catch (UnsupportedOperationException e) {
+            // expected;
+        }
+
+        try {
+            testins.reset();
+        } catch (IOException e) {
+            // expected;
+        }
+
         // readbc.close() affect testins
         readbc.close();
         assertFalse(readbc.isOpen());
@@ -395,16 +386,35 @@ public class ChannelsTest extends TestCase {
         } catch (ClosedChannelException e) {
             // correct
         }
+
+        // Read methods throw IllegalBlockingModeException if underlying channel
+        // is in non-blocking mode.
+        SocketChannel chan = SocketChannel.open();
+        chan.configureBlocking(false);
+        testins = Channels.newInputStream(chan);
+        try {
+            testins.read();
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            testins.read(new byte[1]);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            testins.read(new byte[1], 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newOutputStream",
-          methodArgs = {java.nio.channels.WritableByteChannel.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newOutputStream",
+        args = {java.nio.channels.WritableByteChannel.class}
+    )
     public void testNewOutputStreamWritableByteChannel_InputNull()
             throws Exception {
         byte[] writebuf = new byte[this.testNum];
@@ -433,16 +443,13 @@ public class ChannelsTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify IllegalBlockingModeException for write methods " +
-            "according to the specification.",
-      targets = {
-        @TestTarget(
-          methodName = "newOutputStream",
-          methodArgs = {java.nio.channels.WritableByteChannel.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newOutputStream",
+        args = {java.nio.channels.WritableByteChannel.class}
+    )
     public void testNewOutputStreamWritableByteChannel() throws Exception {
         byte[] writebuf = new byte[this.testNum];
         ByteBuffer writebcbuf = ByteBuffer.allocateDirect(this.testNum);
@@ -468,17 +475,35 @@ public class ChannelsTest extends TestCase {
         } catch (ClosedChannelException e) {
             // correct
         }
+
+        // Write methods throw IllegalBlockingModeException if underlying 
+        // channel is in non-blocking mode.
+        SocketChannel chan = SocketChannel.open();
+        chan.configureBlocking(false);
+        testouts = Channels.newOutputStream(chan);
+        try {
+            testouts.write(10);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            testouts.write(new byte[1]);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            testouts.write(new byte[1], 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies UnsupportedCharsetException.",
-      targets = {
-        @TestTarget(
-          methodName = "newReader",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, 
-                  java.nio.charset.CharsetDecoder.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedCharsetException.",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.nio.charset.CharsetDecoder.class, int.class}
+    )
     public void testnewReaderCharsetError() throws Exception {
         this.fins = new FileInputStream(tmpFile);
 
@@ -492,17 +517,31 @@ public class ChannelsTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify IllegalBlockingModeException for " +
-            "non-blocking mode.",
-      targets = {
-        @TestTarget(
-          methodName = "newWriter",
-          methodArgs = {java.nio.channels.WritableByteChannel.class, 
-                  java.nio.charset.CharsetEncoder.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedCharsetException.",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.lang.String.class}
+    )
+    public void testnewReaderCharsetError2() throws Exception {
+        this.fins = new FileInputStream(tmpFile);
+
+        ReadableByteChannel rbChannel = Channels.newChannel(this.fins);
+        try {
+            Channels.newReader(rbChannel, BAD_CODE_SET);
+            fail();
+        } catch (UnsupportedCharsetException e) {
+            // correct
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedCharsetException.",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.nio.charset.CharsetEncoder.class, int.class}
+    )
     public void testnewWriterCharsetError() throws Exception {
         this.fouts = new FileOutputStream(tmpFile);
         WritableByteChannel wbChannel = Channels.newChannel(this.fouts);
@@ -515,21 +554,34 @@ public class ChannelsTest extends TestCase {
         }
     }
 
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedCharsetException.",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.lang.String.class}
+    )
+    public void testnewWriterCharsetError2() throws Exception {
+        this.fouts = new FileOutputStream(tmpFile);
+        WritableByteChannel wbChannel = Channels.newChannel(this.fouts);
+        try {
+            Channels.newWriter(wbChannel, BAD_CODE_SET);
+            fail();
+        } catch (UnsupportedCharsetException e) {
+            // correct
+        }
+    }
+
     /*
      * Test method for
      * 'java.nio.channels.Channels.newReader(ReadableByteChannel, String)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newReader",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, 
-                  java.nio.charset.CharsetDecoder.class, int.class}
-        )
-    })
-    public void testNewReaderReadableByteChannelString_InputNull()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.nio.charset.CharsetDecoder.class, int.class}
+    )
+    public void testNewReaderReadableByteChannelCharsetDecoderI_InputNull()
             throws IOException {
         int bufSize = this.testNum;
         int readres = 0;
@@ -574,18 +626,61 @@ public class ChannelsTest extends TestCase {
      * Test method for
      * 'java.nio.channels.Channels.newReader(ReadableByteChannel, String)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't check IllegalBlockingModeException exception while " +
-            "read method.",
-      targets = {
-        @TestTarget(
-          methodName = "newReader",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, 
-                  java.nio.charset.CharsetDecoder.class, int.class}
-        )
-    })
-    public void testNewReaderReadableByteChannelString_internalBufferZero()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.lang.String.class}
+    )
+    public void testNewReaderReadableByteChannelString_InputNull()
+            throws IOException {
+        int bufSize = this.testNum;
+        int readres = 0;
+        CharBuffer charBuf = CharBuffer.allocate(bufSize);
+        this.fins = new FileInputStream(tmpFile);
+        // channel null
+        Reader testReader = Channels.newReader(null, CODE_SET);
+        assertNotNull(testReader);
+        assertFalse(testReader.ready());
+        try {
+            readres = testReader.read((CharBuffer) null);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+        assertEquals(0, readres);
+        try {
+            readres = testReader.read(charBuf);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+
+        this.fins = null;
+        ReadableByteChannel rbChannel = Channels.newChannel(this.fins);
+        // channel with null inputs
+        testReader = Channels.newReader(rbChannel, CODE_SET);
+        assertNotNull(testReader);
+        assertFalse(testReader.ready());
+        try {
+            readres = testReader.read(charBuf);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+    }
+
+    /*
+     * Test method for
+     * 'java.nio.channels.Channels.newReader(ReadableByteChannel, String)'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.nio.charset.CharsetDecoder.class, int.class}
+    )
+    public void testNewReaderReadableByteChannelCharsetDecoderI_internalBufferZero()
             throws IOException {
         int bufSize = this.testNum;
         int readres = 0;
@@ -630,17 +725,68 @@ public class ChannelsTest extends TestCase {
      * Test method for
      * 'java.nio.channels.Channels.newReader(ReadableByteChannel, String)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify UnsupportedCharsetException.",
-      targets = {
-        @TestTarget(
-          methodName = "newReader",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, 
-                  java.lang.String.class}
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newReader",
+        args = {java.nio.channels.ReadableByteChannel.class, java.lang.String.class}
+    )
+    public void testNewReaderReadableByteChannelString_internalBufferZero()
+            throws IOException {
+        int bufSize = this.testNum;
+        int readres = 0;
+        CharBuffer charBuf = CharBuffer.allocate(bufSize);
+        this.fins = new FileInputStream(tmpFile);
+        // channel null
+        Reader testReader = Channels.newReader(null, CODE_SET);
+        assertNotNull(testReader);
+        assertFalse(testReader.ready());
+        try {
+            readres = testReader.read((CharBuffer) null);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+        assertEquals(0, readres);
+        try {
+            readres = testReader.read(charBuf);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+        this.fins = null;
+        ReadableByteChannel rbChannel = Channels.newChannel(this.fins);
+        // channel with null inputs
+        testReader = Channels.newReader(rbChannel, CODE_SET);
+        assertNotNull(testReader);
+        assertFalse(testReader.ready());
+        try {
+            readres = testReader.read(charBuf);
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+    }
+
+    /*
+     * Test method for
+     * 'java.nio.channels.Channels.newReader(ReadableByteChannel, String)'
+     */
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "newReader",
+            args = {java.nio.channels.ReadableByteChannel.class, java.lang.String.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "newReader",
+            args = {java.nio.channels.ReadableByteChannel.class, java.nio.charset.CharsetDecoder.class, int.class}
         )
     })
-    public void testNewReaderReadableByteChannelString() throws IOException {
+    public void testNewReaderReadableByteChannel() throws IOException {
         int bufSize = this.testNum;
         int readres = 0;
         CharBuffer charBuf = CharBuffer.allocate(bufSize);
@@ -676,16 +822,13 @@ public class ChannelsTest extends TestCase {
     /*
      * Zero-Buffer
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "newWriter",
-          methodArgs = {java.nio.channels.WritableByteChannel.class, java.nio.charset.CharsetEncoder.class, int.class}
-        )
-    })
-    public void testNewWriterWritableByteChannelString_internalBufZero()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.nio.charset.CharsetEncoder.class, int.class}
+    )
+    public void testNewWriterWritableByteChannelCharsetEncoderI_internalBufZero()
             throws IOException {
 
         String writebuf = ""; //$NON-NLS-1$
@@ -734,19 +877,68 @@ public class ChannelsTest extends TestCase {
     }
 
     /*
+     * Zero-Buffer
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.lang.String.class}
+    )
+    public void testNewWriterWritableByteChannelString_internalBufZero()
+            throws IOException {
+
+        String writebuf = ""; //$NON-NLS-1$
+        for (int val = 0; val < this.writebufSize / 2; val++) {
+            writebuf = writebuf + ((char) (val + 64));
+        }
+        // null channel
+        Writer testWriter = Channels.newWriter(null, CODE_SET);
+        // can write to buffer
+        testWriter.write(writebuf);
+        try {
+            testWriter.flush();
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+        try {
+            testWriter.close();
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+
+        // channel with null input
+        this.fouts = null;
+        WritableByteChannel wbChannel = Channels.newChannel(this.fouts);
+        testWriter = Channels.newWriter(wbChannel, CODE_SET);
+        // can write to buffer
+        testWriter.write(writebuf);
+        try {
+            testWriter.flush();
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+        try {
+            testWriter.close();
+            fail();
+        } catch (NullPointerException e) {
+            // correct
+        }
+    }
+
+    /*
      * this test cannot be passed when buffer set to 0!
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify IllegalBlockingModeException for write methods.",
-      targets = {
-        @TestTarget(
-          methodName = "newWriter",
-          methodArgs = {java.nio.channels.WritableByteChannel.class, 
-                  java.nio.charset.CharsetEncoder.class, int.class}
-        )
-    })
-    public void testNewWriterWritableByteChannelString_InputNull()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.nio.charset.CharsetEncoder.class, int.class}
+    )
+    public void testNewWriterWritableByteChannelCharsetEncoderI_InputNull()
             throws IOException {
         this.fouts = new FileOutputStream(tmpFile);
         WritableByteChannel wbChannel = Channels.newChannel(this.fouts);
@@ -766,17 +958,47 @@ public class ChannelsTest extends TestCase {
     }
 
     /*
+     * this test cannot be passed when buffer set to 0!
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "newWriter",
+        args = {java.nio.channels.WritableByteChannel.class, java.lang.String.class}
+    )
+    public void testNewWriterWritableByteChannelString_InputNull()
+            throws IOException {
+        this.fouts = new FileOutputStream(tmpFile);
+        WritableByteChannel wbChannel = Channels.newChannel(this.fouts);
+        Writer testWriter = Channels.newWriter(wbChannel, CODE_SET);
+
+        String writebuf = ""; //$NON-NLS-1$
+        for (int val = 0; val < this.writebufSize / 2; val++) {
+            writebuf = writebuf + ((char) (val + 64));
+        }
+        // can write to buffer
+        testWriter.write(writebuf);
+        testWriter.flush();
+        testWriter.close();
+
+    }
+
+    /*
      * Test method for
      * 'java.nio.channels.Channels.newWriter(WritableByteChannel, String)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify UnsupportedCharsetException.",
-      targets = {
-        @TestTarget(
-          methodName = "newWriter",
-          methodArgs = {java.nio.channels.WritableByteChannel.class, 
-                  java.lang.String.class}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "newWriter",
+            args = {java.nio.channels.WritableByteChannel.class, java.nio.charset.CharsetEncoder.class, int.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "newWriter",
+            args = {java.nio.channels.WritableByteChannel.class, java.lang.String.class}
         )
     })
     public void testNewWriterWritableByteChannelString() throws IOException {
@@ -817,23 +1039,77 @@ public class ChannelsTest extends TestCase {
         testWriter_s.write(writebuf);
         testWriter.flush();
         this.assertFileSizeSame(tmpFile, this.writebufSize / 2 + 1);
+        
+        SocketChannel chan = SocketChannel.open();
+        chan.configureBlocking(false);
+        Writer writer = Channels.newWriter(chan, CODE_SET);
+        try {
+            writer.write(10);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write(new char[10]);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write("test");
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write(new char[10], 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write("test", 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        
+        writer = Channels.newWriter(chan, Charset.forName(
+                CODE_SET).newEncoder(), //$NON-NLS-1$
+                -1);
+        try {
+            writer.write(10);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write(new char[10]);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write("test");
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write(new char[10], 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        try {
+            writer.write("test", 0, 1);
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
     }
     
     /**
      * @tests java.nio.channels.Channels#newReader(ReadableByteChannel channel,
      *        String charsetName)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalBlockingModeException.",
-      targets = {
-        @TestTarget(
-          methodName = "newReader",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, 
-                  java.lang.String.class}
-        )
-    })
-    public void test_newReader_LReadableByteChannel_LString()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalBlockingModeException.",
+        method = "newInputStream",
+        args = {java.nio.channels.ReadableByteChannel.class}
+    )
+    public void test_newInputStream_LReadableByteChannel()
             throws IOException {
         InetSocketAddress localAddr = new InetSocketAddress("127.0.0.1",
                 Support_PortManager.getNextPort());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedByInterruptExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedByInterruptExceptionTest.java
index 4e48945..8b5dcc7 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedByInterruptExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedByInterruptExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,14 +35,19 @@ public class ClosedByInterruptExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedByInterruptException",
+            args = {}
+        )
     })    
     public void testSerializationSelf() throws Exception {
 
@@ -52,14 +57,19 @@ public class ClosedByInterruptExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedByInterruptException",
+            args = {}
+        )
     })    
     public void testSerializationCompatibility() throws Exception {
 
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedChannelExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedChannelExceptionTest.java
index 277ec34..088b7b5 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedChannelExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedChannelExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,14 +35,19 @@ public class ClosedChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedChannelException",
+            args = {}
+        )
     })     
     public void testSerializationSelf() throws Exception {
 
@@ -52,14 +57,19 @@ public class ClosedChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedChannelException",
+            args = {}
+        )
     })     
     public void testSerializationCompatibility() throws Exception {
 
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedSelectorExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedSelectorExceptionTest.java
index 2f00113..145dd22 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedSelectorExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ClosedSelectorExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,14 +35,19 @@ public class ClosedSelectorExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedSelectorException",
+            args = {}
+        )
     })     
     public void testSerializationSelf() throws Exception {
 
@@ -52,14 +57,19 @@ public class ClosedSelectorExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ClosedSelectorException",
+            args = {}
+        )
     })     
     public void testSerializationCompatibility() throws Exception {
 
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ConnectionPendingExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ConnectionPendingExceptionTest.java
index 47496f7..e0d6489 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ConnectionPendingExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ConnectionPendingExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 import dalvik.annotation.TestLevel;
 
@@ -35,15 +35,20 @@ public class ConnectionPendingExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ConnectionPendingException",
+            args = {}
+        )
+    })    
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new ConnectionPendingException());
@@ -52,15 +57,20 @@ public class ConnectionPendingExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "ConnectionPendingException",
+            args = {}
+        )
+    })    
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new ConnectionPendingException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/DatagramChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/DatagramChannelTest.java
index ca6d052..36e0082 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/DatagramChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/DatagramChannelTest.java
@@ -17,8 +17,8 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -31,23 +31,112 @@ import java.net.SocketAddress;
 import java.net.SocketException;
 import java.nio.ByteBuffer;
 import java.nio.channels.AsynchronousCloseException;
+import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.DatagramChannel;
 import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.NotYetConnectedException;
+import java.nio.channels.SelectionKey;
 import java.nio.channels.UnresolvedAddressException;
 import java.nio.channels.UnsupportedAddressTypeException;
 import java.nio.channels.spi.SelectorProvider;
-import java.security.Permission;
 
 import junit.framework.TestCase;
 import tests.support.Support_PortManager;
 
 /**
  * Test for DatagramChannel
- * 
+ *
  */
-@TestTargetClass(DatagramChannel.class)
+@TestTargetClass(
+    value = DatagramChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "read",
+            args = {java.nio.ByteBuffer[].class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "read",
+            args = {java.nio.ByteBuffer[].class, int.class, int.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class, int.class, int.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "read",
+            args = {java.nio.ByteBuffer[].class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class, int.class, int.class}
+        )
+    }
+)
 public class DatagramChannelTest extends TestCase {
 
     private static final int CAPACITY_NORMAL = 200;
@@ -127,17 +216,33 @@ public class DatagramChannelTest extends TestCase {
     // Test for methods in abstract class.
     // -------------------------------------------------------------------
     /*
+     * Test method for 'java.nio.channels.DatagramChannel()'
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "DatagramChannel",
+        args = {java.nio.channels.spi.SelectorProvider.class}
+    )
+    public void testConstructor() throws IOException {
+        DatagramChannel channel =
+                SelectorProvider.provider().openDatagramChannel();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+        channel = DatagramChannel.open();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(), channel.provider());
+    }
+
+    /*
      * Test method for 'java.nio.channels.DatagramChannel.validOps()'
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "validOps",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "validOps",
+        args = {}
+    )
     public void testValidOps() {
         MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
                 .provider());
@@ -151,15 +256,12 @@ public class DatagramChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.DatagramChannel.open()'
      */
-    @TestInfo(
-      level = TestLevel.TODO,
-      purpose = "Doesn't call open method.",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies the result of the setUp method.",
+        method = "open",
+        args = {}
+    )
     public void testOpen() {
         MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
                 .provider());
@@ -171,166 +273,379 @@ public class DatagramChannelTest extends TestCase {
     }
 
     /*
-     * Test method for 'java.nio.channels.DatagramChannel.read(ByteBuffer)'
+     * Test method for 'java.nio.channels.DatagramChannel.open()'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " + 
-            "ClosedByInterruptException, IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isOpen",
+        args = {}
+    )
+    public void testIsOpen() throws Exception {
+        assertTrue(this.channel1.isOpen());
+        this.channel1.close();
+        assertFalse(this.channel1.isOpen());
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of DatagramChannel.",
+            method = "validOps",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of DatagramChannel.",
+            method = "provider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of DatagramChannel.",
+            method = "isRegistered",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of DatagramChannel.",
+            method = "isBlocking",
+            args = {}
         )
     })
+    public void testChannelBasicStatus() {
+        DatagramSocket gotSocket = this.channel1.socket();
+        assertFalse(gotSocket.isClosed());
+        assertTrue(this.channel1.isBlocking());
+        assertFalse(this.channel1.isRegistered());
+        assertEquals((SelectionKey.OP_READ | SelectionKey.OP_WRITE),
+                this.channel1.validOps());
+        assertEquals(SelectorProvider.provider(), this.channel1.provider());
+    }
+
+    /*
+     * Test method for 'java.nio.channels.DatagramChannel.read(ByteBuffer)'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void testReadByteBufferArray() throws IOException {
-        final int testNum = 0;
-        long readres = testNum;
-        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
-                .provider());
-        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
-        int bufSize = 10;
-        ByteBuffer[] readBuf = null;
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
         try {
             this.channel1.read(readBuf);
-            fail("Should throw NPE");
+            fail("should throw NotYetConnectedException");
+        } catch (NotYetConnectedException e) {
+            // correct
+        }
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.configureBlocking(false);
+        // note : blocking-mode will make the read process endless!
+        assertEquals(0, this.channel1.read(readBuf));
+        this.channel1.close();
+        assertFalse(this.channel1.isOpen());
+        try {
+            assertEquals(0, this.channel1.read(readBuf));
+        } catch (ClosedChannelException e) {
+            // correct
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testReadByteBufferArray_ConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.configureBlocking(false);
+        // note : blocking-mode will make the read process endless!
+        try {
+            this.channel1.read((ByteBuffer[])null);
+            fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
         try {
-            readres = testMock.read(readBuf);
-            fail("Should throw NPE");
+            this.channel1.read(readBuf);
+            fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
-        readBuf = new ByteBuffer[bufSize];
+        datagramSocket1.close();
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testReadByteBufferArray_NotConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
         try {
-            readres = this.channel1.read(readBuf);
-            fail("Should throw NotYetConnectedException");
+            this.channel1.read((ByteBuffer[])null);
+            fail("should throw NPE");
+        } catch (NullPointerException e) {
+            // correct
+        }
+        try {
+            this.channel1.read(readBuf);
+            fail("should throw NotYetConnectedException");
         } catch (NotYetConnectedException e) {
             // correct
         }
-        readres = testMock.read(readBuf);
-        assertEquals(testNum, readres);
-        readres = testMocknull.read(readBuf);
-        assertEquals(testNum, readres);
     }
 
     /*
-     * Test method for 'java.nio.channels.DatagramChannel.read(ByteBuffer)'
+     * Test method for 'DatagramChannelImpl.write(ByteBuffer[])'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
-    public void testReadByteBufferArray_BufNull() throws IOException {
-        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
-                .provider());
-        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
-
-        ByteBuffer[] readBuf = null;
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify all exceptions according to specification.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_Block() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
         try {
-            this.channel1.read(readBuf);
-            fail("Should throw NPE");
-        } catch (NullPointerException e) {
+            this.channel1.write(writeBuf);
+            fail("Should throw NotYetConnectedException.");
+        } catch (NotYetConnectedException e) {
             // correct
         }
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf));
+        // cannot be buffered again!
+        assertEquals(0, this.channel1.write(writeBuf));
+    }
+
+    public void disabled_testWriteByteBufferArray_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer[] targetBuf = new ByteBuffer[2];
+        targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+        targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.write(targetBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    public void disabled_testWriteByteBufferArray_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer[] targetBuf = new ByteBuffer[2];
+                    targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+                    targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+                    channel1.write(targetBuf);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
         try {
-            testMock.read(readBuf);
-            fail("Should throw NPE");
-        } catch (NullPointerException e) {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
+    /*
+     * Test method for 'DatagramChannelImpl.write(ByteBuffer[])'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_NonBlock() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        // non-block mode
+        this.channel1.configureBlocking(false);
+        try {
+            this.channel1.write(writeBuf);
+            fail("Should throw NotYetConnectedException.");
+        } catch (NotYetConnectedException e) {
             // correct
         }
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf));
+        // cannot be buffered again!
+        assertEquals(0, this.channel1.write(writeBuf));
+        this.channel1.close();
         try {
-            testMocknull.read(readBuf);
-            fail("Should throw NPE");
-        } catch (NullPointerException e) {
+            this.channel1.write(writeBuf, 0, 1);
+            fail("Should throw ClosedChannelEception.");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_BlockClosed() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        // non-block mode
+        this.channel1.configureBlocking(false);
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.close();
+        try {
+            channel1.write(writeBuf);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
             // correct
         }
     }
 
-    /*
-     * Test method for 'java.nio.channels.DatagramChannel.write(ByteBuffer)'
-     */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testWriteByteBuffer() throws IOException {
-        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
-                .provider());
-        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
-        int bufSize = 10;
-        ByteBuffer[] readBuf = null;
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_NonBlockClosed() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.close();
         try {
-            this.channel1.write(readBuf);
-            fail("Should throw NPE");
-        } catch (NullPointerException e) {
+            channel1.write(writeBuf);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
             // correct
         }
+    }
+
+    /*
+     * Test method for 'DatagramChannelImpl.write(ByteBuffer[])'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_NotConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
-            testMock.write(readBuf);
-            fail("Should throw NPE");
+            this.channel1.write((ByteBuffer[])null);
+            fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
-        readBuf = new ByteBuffer[bufSize];
         try {
-            this.channel1.write(readBuf);
-            fail("Should throw NotYetConnectedException");
+            this.channel1.write(writeBuf);
+            fail("should throw NotYetConnectedException");
         } catch (NotYetConnectedException e) {
             // correct
         }
-        long writeres = 0;
-        writeres = testMock.write(readBuf);
-
-        assertEquals(0, writeres);
-        writeres = testMocknull.write(readBuf);
-        assertEquals(0, writeres);
     }
 
     /*
-     * Test method for 'java.nio.channels.DatagramChannel.write(ByteBuffer)'
-     */
-    @TestInfo(
-          level = TestLevel.PARTIAL,
-          purpose = "",
-          targets = {
-            @TestTarget(
-              methodName = "write",
-              methodArgs = {java.nio.ByteBuffer[].class}
-            )
-        })
-    public void testWriteByteBuffer_Bufnull() throws IOException {
-        MockDatagramChannel testMock = new MockDatagramChannel(SelectorProvider
-                .provider());
-        MockDatagramChannel testMocknull = new MockDatagramChannel(null);
-        ByteBuffer[] readBuf = null;
+     * Test method for 'DatagramChannelImpl.write(ByteBuffer[])'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testWriteByteBufferArray_ConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
         try {
-            this.channel1.write(readBuf);
-            fail("Should throw NPE");
+            this.channel1.write((ByteBuffer[])null);
+            fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
         try {
-            testMock.write(readBuf);
-            fail("Should throw NPE");
+            this.channel1.write(writeBuf);
+            fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // correct
         }
+        datagramSocket1.close();
         try {
-            testMocknull.write(readBuf);
-            fail("Should throw NPE");
+            this.channel1.write((ByteBuffer[])null);
+            fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
@@ -342,18 +657,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.socket()'
-     * 
+     *
      * @throws SocketException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_BasicStatusBeforeConnect() throws SocketException {
         assertFalse(this.channel1.isConnected());// not connected
         DatagramSocket s1 = this.channel1.socket();
@@ -365,18 +677,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.socket()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_Block_BasicStatusAfterConnect() throws IOException {
         this.channel1.connect(localAddr1);
         DatagramSocket s1 = this.channel1.socket();
@@ -385,17 +694,15 @@ public class DatagramChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_NonBlock_BasicStatusAfterConnect()
-            throws IOException {        
+            throws IOException {
         this.channel1.connect(localAddr1);
         this.channel1.configureBlocking(false);
         DatagramSocket s1 = this.channel1.socket();
@@ -407,18 +714,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.socket()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_ActionsBeforeConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         DatagramSocket s = this.channel1.socket();
@@ -427,33 +731,28 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.socket()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_Block_ActionsAfterConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         this.channel1.connect(localAddr1);
         DatagramSocket s = this.channel1.socket();
         assertSocketActionAfterConnect(s);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_NonBlock_ActionsAfterConnect() throws IOException {
         this.channel1.connect(localAddr1);
         this.channel1.configureBlocking(false);
@@ -494,8 +793,8 @@ public class DatagramChannelTest extends TestCase {
         assertEquals(s.getPort(), localAddr1.getPort());
         assertTrue(s.getReceiveBufferSize() >= 8192);
         // not same , but equals
-        assertNotSame(s.getRemoteSocketAddress(), (SocketAddress) localAddr1);
-        assertEquals(s.getRemoteSocketAddress(), (SocketAddress) localAddr1);
+        assertNotSame(s.getRemoteSocketAddress(), localAddr1);
+        assertEquals(s.getRemoteSocketAddress(), localAddr1);
         assertFalse(s.getReuseAddress());
         assertTrue(s.getSendBufferSize() >= 8192);
         assertEquals(s.getSoTimeout(), 0);
@@ -538,15 +837,12 @@ public class DatagramChannelTest extends TestCase {
     // -------------------------------------------------------------------
     // Test for configureBlocking()
     // -------------------------------------------------------------------
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "configureBlocking",
-          methodArgs = {boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {ByteBuffer.class}
+    )
     public void testConfigureBlocking_Read() throws Exception {
         assertTrue(this.channel1.isBlocking());
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_1KB);
@@ -572,20 +868,18 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.isConnected()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isConnected",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isConnected",
+        args = {}
+    )
     public void testIsConnected_WithServer() throws IOException {
         connectLocalServer();
+        assertTrue(this.channel1.isConnected());
         disconnectAfterConnected();
         this.datagramSocket1.close();
         this.channel1.close();
@@ -599,15 +893,12 @@ public class DatagramChannelTest extends TestCase {
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_BlockWithServer() throws IOException {
         // blocking mode
         assertTrue(this.channel1.isBlocking());
@@ -615,20 +906,16 @@ public class DatagramChannelTest extends TestCase {
         datagramSocket1.close();
         disconnectAfterConnected();
     }
-    
+
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " +
-            "ClosedByInterruptException, SecurityException, IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_BlockNoServer() throws IOException {
         connectWithoutServer();
         disconnectAfterConnected();
@@ -636,18 +923,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_NonBlockWithServer() throws IOException {
         // Non blocking mode
         this.channel1.configureBlocking(false);
@@ -658,18 +942,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies IllegalArgumentException.",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_Null() throws IOException {
         assertFalse(this.channel1.isConnected());
         try {
@@ -682,18 +963,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies UnsupportedAddressTypeException.",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnsupportedAddressTypeException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_UnsupportedType() throws IOException {
         assertFalse(this.channel1.isConnected());
         class SubSocketAddress extends SocketAddress {
@@ -712,20 +990,65 @@ public class DatagramChannelTest extends TestCase {
         }
     }
 
+    public void disabled_testConnect_Block_close() throws Exception {
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.connect(localAddr1);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    public void disabled_testConnect_Block_interrupt() throws Exception {
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    channel1.connect(localAddr1);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies UnresolvedAddressException.",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies UnresolvedAddressException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_Unresolved() throws IOException {
         assertFalse(this.channel1.isConnected());
         InetSocketAddress unresolved = new InetSocketAddress(
@@ -737,15 +1060,13 @@ public class DatagramChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_EmptyHost() throws Exception {
         assertFalse(this.channel1.isConnected());
 
@@ -756,19 +1077,16 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
-     * 
-     */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })    
+     *
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_ClosedChannelException() throws IOException {
         assertFalse(this.channel1.isConnected());
         this.channel1.close();
@@ -783,19 +1101,16 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
-     * 
-     */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies IllegalStateException.",
-              targets = {
-                @TestTarget(
-                  methodName = "connect",
-                  methodArgs = {java.net.SocketAddress.class}
-                )
-            })
+     *
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalStateException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_IllegalStateException() throws IOException {
         assertFalse(this.channel1.isConnected());
         this.channel1.connect(localAddr1);
@@ -811,19 +1126,16 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.connect(SocketAddress)'
-     * 
+     *
      * @throws IOException
-     * 
-     */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+     *
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testConnect_CheckOpenBeforeStatus() throws IOException {
         assertFalse(this.channel1.isConnected());
         this.channel1.connect(localAddr1);
@@ -874,18 +1186,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify IOException.",
+        method = "disconnect",
+        args = {}
+    )
     public void testDisconnect_BeforeConnect() throws IOException {
         assertFalse(this.channel1.isConnected());
         assertEquals(this.channel1, this.channel1.disconnect());
@@ -894,18 +1203,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "disconnect",
+        args = {}
+    )
     public void testDisconnect_UnconnectedClosed() throws IOException {
         assertFalse(this.channel1.isConnected());
         this.channel1.close();
@@ -916,18 +1222,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "disconnect",
+        args = {}
+    )
     public void testDisconnect_BlockWithServerChannelClosed()
             throws IOException {
         assertTrue(this.channel1.isBlocking());
@@ -939,18 +1242,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "disconnect",
+        args = {}
+    )
     public void testDisconnect_NonBlockWithServerChannelClosed()
             throws IOException {
         this.channel1.configureBlocking(false);
@@ -962,19 +1262,17 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
-    public void testDisconnect_BlockWithServerServerClosed() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "disconnect",
+        args = {}
+    )
+    public void testDisconnect_BlockWithServerServerClosed()
+            throws IOException {
         assertTrue(this.channel1.isBlocking());
         connectLocalServer();
         // disconnect after server close
@@ -986,18 +1284,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.disconnect()'
-     * 
+     *
      * @throws IOException
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "disconnect",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "disconnect",
+        args = {}
+    )
     public void testDisconnect_NonBlockWithServerServerClosed()
             throws IOException {
         this.channel1.configureBlocking(false);
@@ -1016,18 +1311,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedNull() throws Exception {
         assertFalse(this.channel1.isConnected());
         try {
@@ -1040,18 +1332,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedReadonly() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
@@ -1067,18 +1356,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedBufEmpty() throws Exception {
         this.channel1.configureBlocking(false);
         assertFalse(this.channel1.isConnected());
@@ -1088,18 +1374,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedBufZero() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_ZERO);
@@ -1108,18 +1391,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedBufNotEmpty() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
@@ -1131,18 +1411,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedBufFull() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_ONE);
@@ -1154,18 +1431,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedClose() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
@@ -1181,18 +1455,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedCloseNull() throws Exception {
         assertFalse(this.channel1.isConnected());
         this.channel1.close();
@@ -1208,18 +1479,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_UnconnectedCloseReadonly() throws Exception {
         assertFalse(this.channel1.isConnected());
         ByteBuffer dst = ByteBuffer.allocateDirect(CAPACITY_NORMAL)
@@ -1237,18 +1505,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerBufEmpty() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNonBlockNoServer(CAPACITY_NORMAL);
@@ -1256,18 +1521,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_BlockNoServerNull() throws Exception {
         assertTrue(this.channel1.isBlocking());
         receiveNoServerNull();
@@ -1275,18 +1537,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerNull() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNoServerNull();
@@ -1294,18 +1553,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_BlockNoServerReadonly() throws Exception {
         assertTrue(this.channel1.isBlocking());
         receiveNoServerReadonly();
@@ -1313,18 +1569,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerReadonly() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNoServerReadonly();
@@ -1332,18 +1585,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerBufZero() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNonBlockNoServer(CAPACITY_ZERO);
@@ -1351,18 +1601,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerBufNotEmpty() throws Exception {
         this.channel1.configureBlocking(false);
         connectWithoutServer();
@@ -1373,18 +1620,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerBufFull() throws Exception {
         this.channel1.configureBlocking(false);
         connectWithoutServer();
@@ -1394,18 +1638,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "receive",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_BlockNoServerChannelClose() throws Exception {
         assertTrue(this.channel1.isBlocking());
         receiveNoServerChannelClose();
@@ -1413,18 +1654,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerChannelClose() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNoServerChannelClose();
@@ -1432,18 +1670,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_BlockNoServerCloseNull() throws Exception {
         assertTrue(this.channel1.isBlocking());
         receiveNoServerChannelCloseNull();
@@ -1451,18 +1686,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerCloseNull() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNoServerChannelCloseNull();
@@ -1470,18 +1702,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "receive",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })       
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_NonBlockNoServerCloseReadonly() throws Exception {
         this.channel1.configureBlocking(false);
         receiveNoServerChannelCloseReadonly();
@@ -1489,18 +1718,15 @@ public class DatagramChannelTest extends TestCase {
 
     /**
      * Test method for 'DatagramChannelImpl.receive(ByteBuffer)'
-     * 
+     *
      * @throws Exception
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceive_BlockNoServerCloseReadonly() throws Exception {
         assertTrue(this.channel1.isBlocking());
         receiveNoServerChannelCloseReadonly();
@@ -1598,63 +1824,56 @@ public class DatagramChannelTest extends TestCase {
 
     private void sendDataBlocking(InetSocketAddress addr, ByteBuffer writeBuf)
             throws IOException {
-        InetSocketAddress ipAddr = addr; 
+        InetSocketAddress ipAddr = addr;
         assertEquals(CAPACITY_NORMAL, this.channel1.send(writeBuf, ipAddr));
         assertTrue(this.channel1.isOpen());
         assertTrue(this.channel1.isBlocking());
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
     }
 
     private void sendDataNonBlocking(InetSocketAddress addr, ByteBuffer writeBuf)
             throws IOException {
-        InetSocketAddress ipAddr = addr; 
+        InetSocketAddress ipAddr = addr;
         this.channel1.configureBlocking(false);
         assertEquals(CAPACITY_NORMAL, this.channel1.send(writeBuf, ipAddr));
         assertTrue(this.channel1.isOpen());
         assertFalse(this.channel1.isBlocking());
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
     }
 
     /*
      * Test method for 'DatagramChannelImpl.send(ByteBuffer, SocketAddress)'
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerBlockingCommon() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         sendDataBlocking(localAddr1, writeBuf);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerNonblockingCommon() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         sendDataNonBlocking(localAddr1, writeBuf);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerTwice() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         sendDataBlocking(localAddr1, writeBuf);
@@ -1667,15 +1886,13 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerNonBlockingTwice() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         sendDataNonBlocking(localAddr1, writeBuf);
@@ -1688,15 +1905,13 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerBufNull() throws IOException {
         try {
             sendDataBlocking(localAddr1, null);
@@ -1705,15 +1920,13 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerBufNullTwice() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
@@ -1730,15 +1943,13 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "DOesn't verify all exceptions according to spec.",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "DOesn't verify all exceptions according to spec.",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerAddrNull() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
@@ -1748,20 +1959,18 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_NoServerAddrNullTwice() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
             sendDataBlocking(null, writeBuf);
-            fail("Should throw a NPE here.");
+            fail("Should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
@@ -1777,19 +1986,20 @@ public class DatagramChannelTest extends TestCase {
     // -------------------------------------------------------------------
     // Test for receive()and send(): Send and Receive with Real Data
     // -------------------------------------------------------------------
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Normal() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByChannel("some normal string in testReceiveSend_Normal",
@@ -1797,19 +2007,21 @@ public class DatagramChannelTest extends TestCase {
         receiveByChannel(CAPACITY_NORMAL, localAddr2,
                 "some normal string in testReceiveSend_Normal");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_NotBound() throws Exception {
         // not bound
         sendByChannel("some normal string in testReceiveSend_Normal",
@@ -1818,19 +2030,21 @@ public class DatagramChannelTest extends TestCase {
         assertNull(channel1.receive(buf));
         assertFalse(channel1.socket().isBound());
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_NotBound() throws Exception {
         // not bound
         this.channel1.configureBlocking(false);
@@ -1838,21 +2052,23 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel("some normal string in testReceiveSend_Normal",
                 localAddr2);
         ByteBuffer buf = ByteBuffer.wrap(new byte[CAPACITY_NORMAL]);
-        assertNull((InetSocketAddress) this.channel1.receive(buf));
-    }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+        assertNull(this.channel1.receive(buf));
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Normal_S2C() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByDatagramSocket(
@@ -1860,38 +2076,42 @@ public class DatagramChannelTest extends TestCase {
         receiveByChannel(CAPACITY_NORMAL, localAddr2,
                 "some normal string in testReceiveSend_Normal_S2C");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Normal_C2S() throws Exception {
         this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
         String str1 = "some normal string in testReceiveSend_Normal_C2S";
         sendByChannel(str1, localAddr2);
         receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, str1);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_Normal_C2S() throws Exception {
         this.channel1.configureBlocking(false);
         this.channel2.configureBlocking(false);
@@ -1900,19 +2120,21 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel(str1, localAddr2);
         receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, str1);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Normal_S2S() throws Exception {
         String msg = "normal string in testReceiveSend_Normal_S2S";
         this.datagramSocket1 = new DatagramSocket(testPort);
@@ -1926,33 +2148,41 @@ public class DatagramChannelTest extends TestCase {
         this.datagramSocket2.receive(rdp);
         assertEquals(new String(buf, 0, CAPACITY_NORMAL).trim(), msg);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Empty() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByChannel("", localAddr2);
         receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_Empty() throws Exception {
         this.channel1.configureBlocking(false);
         this.channel2.configureBlocking(false);
@@ -1960,37 +2190,41 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel("", localAddr2);
         receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Empty_S2C() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByDatagramSocket("", localAddr2);
         receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_Empty_S2C() throws Exception {
         this.channel1.configureBlocking(false);
         this.channel2.configureBlocking(false);
@@ -1998,37 +2232,41 @@ public class DatagramChannelTest extends TestCase {
         sendByDatagramSocket("", localAddr2);
         receiveByChannel(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Empty_C2S() throws Exception {
         this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
         sendByChannel("", localAddr2);
         receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_Empty_C2S() throws Exception {
         this.channel1.configureBlocking(false);
         this.channel2.configureBlocking(false);
@@ -2036,15 +2274,13 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel("", localAddr2);
         receiveByDatagramSocket(CAPACITY_NORMAL, localAddr2, "");
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReceiveSend_Empty_S2S() throws Exception {
         String msg = "";
         this.datagramSocket1 = new DatagramSocket(testPort);
@@ -2058,55 +2294,61 @@ public class DatagramChannelTest extends TestCase {
         this.datagramSocket2.receive(rdp);
         assertEquals(new String(buf, 0, CAPACITY_NORMAL).trim(), msg);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Oversize() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByChannel("0123456789", localAddr2);
         receiveByChannel(5, localAddr2, "01234");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Oversize_C2S() throws Exception {
         this.datagramSocket1 = new DatagramSocket(localAddr2.getPort());
         sendByChannel("0123456789", localAddr2);
         receiveByDatagramSocket(5, localAddr2, "01234");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_NonBlock_Oversize_C2S() throws Exception {
         this.channel1.configureBlocking(false);
         this.channel2.configureBlocking(false);
@@ -2114,37 +2356,41 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel("0123456789", localAddr2);
         receiveByDatagramSocket(5, localAddr2, "01234");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_Block_Oversize_S2C() throws Exception {
         this.channel1.socket().bind(localAddr2);
         sendByDatagramSocket("0123456789", localAddr2);
         receiveByChannel(5, localAddr2, "01234");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "receive",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "send",
-                methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-            )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "receive",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "send",
+            args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+        )
+    })
     public void testReceiveSend_8K() throws Exception {
         StringBuffer str8k = new StringBuffer();
         for (int i = 0; i < 8 * CAPACITY_1KB; i++) {
@@ -2155,16 +2401,13 @@ public class DatagramChannelTest extends TestCase {
         sendByChannel(str, localAddr2);
         receiveByChannel(8 * CAPACITY_1KB, localAddr2, str);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Doesn't verify AsynchronousCloseException, " +
-                    "ClosedByInterruptException.",
-              targets = {
-                @TestTarget(
-                  methodName = "send",
-                  methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-                )
-            })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testReceiveSend_64K() throws Exception {
         StringBuffer str64k = new StringBuffer();
         for (int i = 0; i < CAPACITY_64KB; i++) {
@@ -2227,7 +2470,7 @@ public class DatagramChannelTest extends TestCase {
             this.channel1.close();
         }
     }
-    
+
     /*
      * Fails if the difference between current time and start time is greater
      * than timeout.
@@ -2256,15 +2499,13 @@ public class DatagramChannelTest extends TestCase {
     private class mockAddress extends SocketAddress {
         private static final long serialVersionUID = 1L;
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "send",
-          methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
     public void testSend_MockSocketAddress() throws Exception {
 
         SocketAddress badAddr = new mockAddress();
@@ -2288,58 +2529,217 @@ public class DatagramChannelTest extends TestCase {
             System.setSecurityManager(sm);
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " + 
-            "ClosedByInterruptException, IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testRead_Security() throws Exception {        
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify AsynchronousCloseException, ClosedByInterruptException, IOException.",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, SocketAddress.class}
+    )
+    public void testSend_Security() throws Exception {
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
         String strHello = "hello";
         localAddr1 = new InetSocketAddress("127.0.0.1", testPort);
         this.channel1.socket().bind(localAddr1);
         this.channel2.socket().bind(localAddr2);
         this.channel1.connect(localAddr2);
-        this.channel2.send(ByteBuffer.wrap(strHello.getBytes()), localAddr1);
+
         final SecurityManager sm = System.getSecurityManager();
-        System.setSecurityManager(new MockSecurityManager("10.0.0.1"));
+        MockSecurityManager mockManager = new MockSecurityManager("127.0.0.1");
+        System.setSecurityManager(mockManager);
 
-        // seems no security check
         try {
+            this.channel2.send(ByteBuffer.wrap(strHello.getBytes()), localAddr1);
             assertEquals(strHello.length(), this.channel1.read(buf));
         } finally {
             System.setSecurityManager(sm);
         }
+
+        assertTrue(mockManager.checkConnectCalled);
+    }
+
+    public void disabled_testSend_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.send(targetBuf, localAddr1);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "receive",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
-    public void testReceive_Peek_Security_Nonblocking() throws Exception {        
+
+    public void disabled_testSend_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+                    channel1.send(targetBuf, localAddr1);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReceive_Security() throws Exception {
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
         String strHello = "hello";
         localAddr1 = new InetSocketAddress("127.0.0.1", testPort);
         this.channel1.socket().bind(localAddr1);
         sendByChannel(strHello, localAddr1);
+
         final SecurityManager sm = System.getSecurityManager();
+        MockSecurityManager mockManager = new MockSecurityManager("10.0.0.1");
+        System.setSecurityManager(mockManager);
+
         try {
-            System.setSecurityManager(new MockSecurityManager("10.0.0.1"));
             this.channel1.configureBlocking(false);
-            // for accepted addr, no problem.
             assertNull(this.channel1.receive(buf));
         } finally {
             System.setSecurityManager(sm);
         }
+
+        assertTrue(mockManager.checkAcceptCalled);
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReceive_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.receive(targetBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "receive",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReceive_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+                    channel1.receive(targetBuf);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
+    public void testConnect_Security() throws IOException {
+        localAddr1 = new InetSocketAddress("127.0.0.1", testPort);
+        SecurityManager sm = System.getSecurityManager();
+        MockSecurityManager mockManager = new MockSecurityManager("127.0.0.1");
+        System.setSecurityManager(mockManager);
+
+        try {
+            this.channel1.connect(localAddr1);
+        } finally {
+            System.setSecurityManager(sm);
+        }
+
+        assertTrue(mockManager.checkConnectCalled);
     }
 
     // -------------------------------------------------------------------
@@ -2348,7 +2748,7 @@ public class DatagramChannelTest extends TestCase {
 
     private void connectWriteBuf(InetSocketAddress ipAddr, ByteBuffer buf)
             throws IOException {
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         assertEquals(CAPACITY_NORMAL, this.channel1.write(buf));
         assertEquals(0, this.channel1.write(buf));
@@ -2366,47 +2766,40 @@ public class DatagramChannelTest extends TestCase {
     /*
      * Test method for 'DatagramChannelImpl.write(ByteBuffer)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testWriteByteBuffer_Block() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         connectWriteBuf(localAddr1, writeBuf);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testWriteByteBuffer_NonBlock() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         this.channel1.configureBlocking(false);
         connectWriteBuf(localAddr1, writeBuf);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testWriteByteBuffer_Block_closed() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testWriteByteBuffer_BlockClosed() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         noconnectWrite(writeBuf);
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         this.channel1.close();
         try {
@@ -2416,22 +2809,20 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testWriteByteBuffer_NonBlock_closed() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testWriteByteBuffer_NonBlockClosed() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         // non block mode
         this.channel1.configureBlocking(false);
         noconnectWrite(writeBuf);
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         this.channel1.close();
         try {
@@ -2441,25 +2832,23 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testWriteByteBuffer_Block_BufNull() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testWriteByteBuffer_BlockBufNull() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(0);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         try {
             this.channel1.write((ByteBuffer) null);
             fail("Should throw NPE.");
         } catch (NullPointerException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         try {
             this.channel1.write((ByteBuffer) null);
@@ -2476,18 +2865,16 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testWriteByteBuffer_NonBlock_BufNull() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testWriteByteBuffer_NonBlockBufNull() throws IOException {
         ByteBuffer writeBuf = ByteBuffer.allocateDirect(0);
-        InetSocketAddress ipAddr = localAddr1;     
+        InetSocketAddress ipAddr = localAddr1;
 
         // non block mode
         this.channel1.configureBlocking(false);
@@ -2498,7 +2885,7 @@ public class DatagramChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         try {
             this.channel1.write((ByteBuffer) null);
@@ -2519,47 +2906,114 @@ public class DatagramChannelTest extends TestCase {
     /*
      * Test method for 'DatagramChannelImpl.write(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void testWriteByteBufferArrayIntInt_Block() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify all exceptions according to specification.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_Block() throws IOException {
         ByteBuffer[] writeBuf = new ByteBuffer[2];
         writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         try {
             this.channel1.write(writeBuf, 0, 2);
             fail("Should throw NotYetConnectedException.");
         } catch (NotYetConnectedException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
         // cannot be buffered again!
         assertEquals(0, this.channel1.write(writeBuf, 0, 1));
+        this.channel1.close();
+        try {
+            this.channel1.write(writeBuf, 0, 1);
+            fail("Should throw ClosedChannelEception.");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+    }
+
+    public void disabled_testWriteByteBufferArrayII_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer[] targetBuf = new ByteBuffer[2];
+        targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+        targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.write(targetBuf, 0 ,2);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    public void disabled_testWriteByteBufferArrayII_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
 
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer[] targetBuf = new ByteBuffer[2];
+                    targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+                    targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+                    channel1.write(targetBuf, 0, 2);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
-    public void testWriteByteBufferArrayIntInt_NonBlock() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_NonBlock() throws IOException {
         ByteBuffer[] writeBuf = new ByteBuffer[2];
         writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         // non-block mode
         this.channel1.configureBlocking(false);
         try {
@@ -2568,30 +3022,80 @@ public class DatagramChannelTest extends TestCase {
         } catch (NotYetConnectedException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
         // cannot be buffered again!
         assertEquals(0, this.channel1.write(writeBuf, 0, 1));
+        this.channel1.close();
+        try {
+            this.channel1.write(writeBuf, 0, 1);
+            fail("Should throw ClosedChannelEception.");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_BlockClosed() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        // non-block mode
+        this.channel1.configureBlocking(false);
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.close();
+        try {
+            channel1.write(writeBuf, 0, 2);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // correct
+        }
+    }
 
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_NonBlockClosed() throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.close();
+        try {
+            channel1.write(writeBuf, 0, 2);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // correct
+        }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
-    public void testWriteByteBufferArrayIntInt_NoConnectIndexBad()
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_NotConnectedIndexBad()
             throws IOException {
         ByteBuffer[] writeBuf = new ByteBuffer[2];
         writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         try {
-            this.channel1.write(writeBuf, -1, 2);
+            this.channel1.write(writeBuf, -1, 0);
             fail("should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
@@ -2602,31 +3106,48 @@ public class DatagramChannelTest extends TestCase {
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
-        assertTrue(this.channel1.isConnected());
-        assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
-        // cannot be buffered again!
-        assertEquals(0, this.channel1.write(writeBuf, 0, 1));
+        try {
+            this.channel1.write(writeBuf, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(writeBuf, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(writeBuf, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(writeBuf, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
-    public void testWriteByteBufferArrayIntInt_ConnectedIndexBad()
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_ConnectedIndexBad()
             throws IOException {
         ByteBuffer[] writeBuf = new ByteBuffer[2];
         writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         writeBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
-        this.channel1.connect(ipAddr); 
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         try {
-            this.channel1.write(writeBuf, -1, 2);
+            this.channel1.write(writeBuf, -1, 0);
             fail("should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
@@ -2637,74 +3158,94 @@ public class DatagramChannelTest extends TestCase {
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
-    }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
-    public void testWriteByteBufferArrayIntInt_BufNullNoConnect()
-            throws IOException {
-        ByteBuffer[] writeBuf = new ByteBuffer[2];
-        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
-            this.channel1.write(null, 0, 2);
-            fail("should throw NPE");
-        } catch (NullPointerException e) {
+            this.channel1.write(writeBuf, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(writeBuf, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
             // correct
         }
         try {
-            this.channel1.write(null, -1, 2);
+            this.channel1.write(writeBuf, 2, 1);
             fail("should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
         try {
-            this.channel1.write(null, 0, 3);
+            this.channel1.write(writeBuf, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_NotConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] writeBuf = new ByteBuffer[2];
+        writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        try {
+            this.channel1.write(null, 0, 20);
             fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
+        try {
+            this.channel1.write(writeBuf, 0, 2);
+            fail("should throw NotYetConnectedException");
+        } catch (NotYetConnectedException e) {
+            // correct
+        }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-    })
-    public void testWriteByteBufferArrayIntInt_BufNullConnect()
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testWriteByteBufferArrayII_ConnectedBufNull()
             throws IOException {
         ByteBuffer[] writeBuf = new ByteBuffer[2];
         writeBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
-        this.channel1.connect(ipAddr); 
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         try {
-            this.channel1.write(null, 0, 2);
+            this.channel1.write(null, 0, 20);
             fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
         try {
-            this.channel1.write(writeBuf, 0, 3);
-            fail("should throw IndexOutOfBoundsException");
-        } catch (IndexOutOfBoundsException e) {
+            this.channel1.write(writeBuf, 0, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
             // correct
         }
         datagramSocket1.close();
         try {
-            this.channel1.write(null, 0, 2);
+            this.channel1.write(null, 0, 20);
             fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
+        try {
+            this.channel1.write(writeBuf, 0, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // correct
+        }
     }
 
     // -------------------------------------------------------------------
@@ -2714,15 +3255,12 @@ public class DatagramChannelTest extends TestCase {
     /*
      * Test method for 'DatagramChannelImpl.read(ByteBuffer)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadByteBuffer() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         try {
@@ -2731,7 +3269,7 @@ public class DatagramChannelTest extends TestCase {
         } catch (NotYetConnectedException e) {
             // correct
         }
-        this.channel1.connect(localAddr1); 
+        this.channel1.connect(localAddr1);
         assertTrue(this.channel1.isConnected());
         this.channel1.configureBlocking(false);
         // note : blocking-mode will make the read process endless!
@@ -2744,25 +3282,23 @@ public class DatagramChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void testReadByteBuffer_bufNull() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer_BufNull() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocateDirect(0);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         try {
             this.channel1.read(readBuf);
             fail("should throw NotYetConnectedException");
         } catch (NotYetConnectedException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         try {
             channel1.read((ByteBuffer) null);
@@ -2779,33 +3315,37 @@ public class DatagramChannelTest extends TestCase {
     /*
      * Test method for 'DatagramChannelImpl.read(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " + 
-            "ClosedByInterruptException, IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void testReadByteBufferArrayIntInt() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify AsynchronousCloseException, ClosedByInterruptException, IOException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII() throws IOException {
         ByteBuffer[] readBuf = new ByteBuffer[2];
         readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
         readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
+        InetSocketAddress ipAddr = localAddr1;
         try {
             this.channel1.read(readBuf, 0, 2);
             fail("should throw NotYetConnectedException");
         } catch (NotYetConnectedException e) {
             // correct
         }
-        this.channel1.connect(ipAddr); 
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         this.channel1.configureBlocking(false);
         // note : blocking-mode will make the read process endless!
         assertEquals(0, this.channel1.read(readBuf, 0, 1));
         assertEquals(0, this.channel1.read(readBuf, 0, 2));
+        this.channel1.close();
+        assertFalse(this.channel1.isOpen());
+        try {
+            assertEquals(0, this.channel1.read(readBuf, 0, 1));
+        } catch (ClosedChannelException e) {
+            // correct
+        }
+
         datagramSocket1.close();
         //regression test for HARMONY-932
         try {
@@ -2827,31 +3367,24 @@ public class DatagramChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void testReadByteBufferArrayIntInt_BufNull() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII_ConnectedBufNull()
+            throws IOException {
         ByteBuffer[] readBuf = new ByteBuffer[2];
         readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        InetSocketAddress ipAddr = localAddr1; 
-        try {
-            this.channel1.read(null, 0, 0);
-            fail("should throw NPE");
-        } catch (NullPointerException e) {
-            // correct
-        }
-        this.channel1.connect(ipAddr); 
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
         assertTrue(this.channel1.isConnected());
         this.channel1.configureBlocking(false);
         // note : blocking-mode will make the read process endless!
         try {
-            this.channel1.read(null, 0, 0);
+            this.channel1.read(null, 0, 2);
             fail("should throw NPE");
         } catch (NullPointerException e) {
             // correct
@@ -2863,31 +3396,218 @@ public class DatagramChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // correct
         }
+        datagramSocket1.close();
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII_NotConnectedBufNull()
+            throws IOException {
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        try {
+            this.channel1.read(null, 0, 2);
+            fail("should throw NPE");
+        } catch (NullPointerException e) {
+            // correct
+        }
+        try {
+            this.channel1.read(readBuf, 0, 2);
+            fail("should throw NotYetConnectedException");
+        } catch (NotYetConnectedException e) {
+            // correct
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII_ConnectedIndexBad() throws IOException {
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        this.channel1.connect(ipAddr);
+        assertTrue(this.channel1.isConnected());
+        this.channel1.configureBlocking(false);
+        // note : blocking-mode will make the read process endless!
+        try {
+            this.channel1.read(readBuf, -1, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.read(readBuf, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
         try {
             this.channel1.read(readBuf, 0, 3);
             fail("should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
-        datagramSocket1.close();
+        try {
+            this.channel1.read(readBuf, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.read(readBuf, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.read(readBuf, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII_NotConnectedIndexBad()
+            throws IOException {
+        ByteBuffer[] readBuf = new ByteBuffer[2];
+        readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+        InetSocketAddress ipAddr = localAddr1;
+        try {
+            this.channel1.write(readBuf, -1, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(readBuf, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(readBuf, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(readBuf, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(readBuf, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+        try {
+            this.channel1.write(readBuf, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // correct
+        }
+    }
+
+    public void disabled_testReadByteBufferArrayII_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer[] targetBuf = new ByteBuffer[2];
+        targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+        targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.read(targetBuf, 0, 2);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer[] targetBuf = new ByteBuffer[2];
+                    targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+                    targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+                    channel1.read(targetBuf, 0, 2);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
     }
 
     // -------------------------------------------------------------------
     // test read and write
     // -------------------------------------------------------------------
-    @TestInfo(
-          level = TestLevel.PARTIAL,
-          purpose = "",
-          targets = {
-            @TestTarget(
-              methodName = "read",
-              methodArgs = {java.nio.ByteBuffer.class}
-            ),
-            @TestTarget(
-              methodName = "configureBlocking",
-              methodArgs = {boolean.class}
-            )
-        })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadWrite_configureBlock() throws Exception {
         byte[] targetArray = new byte[2];
         // bind and connect
@@ -2914,14 +3634,38 @@ public class DatagramChannelTest extends TestCase {
         } catch (AsynchronousCloseException e) {
             // ok
         }
+        this.channel1.close();
+        try {
+            this.channel1.configureBlocking(true);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+        
+        this.channel1 = SelectorProvider.provider().openDatagramChannel();
+        this.channel1.configureBlocking(false);
+        this.channel1.register(SelectorProvider.provider().openSelector(),
+                SelectionKey.OP_READ);
+        try {
+            this.channel1.configureBlocking(true);
+            fail("should throw IllegalBlockingModeException");
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_Zero() throws Exception {
@@ -2939,23 +3683,23 @@ public class DatagramChannelTest extends TestCase {
 
         // read
         ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
-        int readCount = this.channel2.read(targetBuf);
-
-        assertEquals(0, readCount);
-    }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "read",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                ),              
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+        assertEquals(0, this.channel2.read(targetBuf));
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_Block_Normal() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_NORMAL];
         byte[] targetArray = new byte[CAPACITY_NORMAL];
@@ -2972,13 +3716,19 @@ public class DatagramChannelTest extends TestCase {
         readWriteReadData(this.channel1, sourceArray, this.channel2,
                 targetArray, CAPACITY_NORMAL, "testReadWrite_Block_Normal");
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_Empty() throws Exception {
@@ -3002,19 +3752,21 @@ public class DatagramChannelTest extends TestCase {
         // empty message let the reader blocked
         closeBlockedReaderChannel2(targetBuf);
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "read",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                ),              
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_changeBlock_Empty() throws Exception {
         // empty buf
         byte[] sourceArray = "".getBytes();
@@ -3055,19 +3807,21 @@ public class DatagramChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "read",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                ),              
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_Block_8KB() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_1KB * 8];
         byte[] targetArray = new byte[CAPACITY_1KB * 8];
@@ -3118,16 +3872,13 @@ public class DatagramChannelTest extends TestCase {
             assertEquals(targetArray[i], (byte) i);
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify NotYetConnectedException, " +
-            "ClosedChannelException, ClosedByInterruptException.",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadWrite_Block_64K() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_64KB];
         for (int i = 0; i < sourceArray.length; i++) {
@@ -3149,13 +3900,19 @@ public class DatagramChannelTest extends TestCase {
             // too big
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_DifferentAddr() throws Exception {
@@ -3181,13 +3938,19 @@ public class DatagramChannelTest extends TestCase {
         // we close the blocked channel
         closeBlockedReaderChannel2(targetBuf);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_WriterNotBind() throws Exception {
@@ -3210,13 +3973,19 @@ public class DatagramChannelTest extends TestCase {
         ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
         closeBlockedReaderChannel2(targetBuf);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_WriterBindLater() throws Exception {
@@ -3270,13 +4039,19 @@ public class DatagramChannelTest extends TestCase {
         }
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
         )
     })
     public void testReadWrite_Block_ReaderNotBind() throws Exception {
@@ -3326,19 +4101,20 @@ public class DatagramChannelTest extends TestCase {
     // -------------------------------------------------------------------
     // Test read and write in non-block mode.
     // -------------------------------------------------------------------
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),              
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_NonBlock_Normal() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_NORMAL];
         byte[] targetArray = new byte[CAPACITY_NORMAL];
@@ -3358,19 +4134,21 @@ public class DatagramChannelTest extends TestCase {
         readWriteReadData(this.channel1, sourceArray, this.channel2,
                 targetArray, CAPACITY_NORMAL, "testReadWrite_NonBlock_Normal");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),              
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_NonBlock_8KB() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_1KB * 8];
         byte[] targetArray = new byte[CAPACITY_1KB * 8];
@@ -3390,19 +4168,21 @@ public class DatagramChannelTest extends TestCase {
         readWriteReadData(this.channel1, sourceArray, this.channel2,
                 targetArray, 8 * CAPACITY_1KB, "testReadWrite_NonBlock_8KB");
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),              
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_NonBlock_DifferentAddr() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_NORMAL];
         byte[] targetArray = new byte[CAPACITY_NORMAL];
@@ -3427,19 +4207,59 @@ public class DatagramChannelTest extends TestCase {
         ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
         assertEquals(0, this.channel2.read(targetBuf));
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),              
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
+    public void testReadWrite_NonBlock_Empty() throws Exception {
+        // empty buf
+        byte[] sourceArray = "".getBytes();
+        byte[] targetArray = new byte[CAPACITY_NORMAL];
+
+        this.channel1.configureBlocking(false);
+        this.channel2.configureBlocking(false);
+
+        // bind and connect
+
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        // write
+        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
+        assertEquals(0, this.channel1.write(sourceBuf));
+
+        // read
+        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
+        assertEquals(0, this.channel2.read(targetBuf));
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_NonBlock_WriterNotBind() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_NORMAL];
         byte[] targetArray = new byte[CAPACITY_NORMAL];
@@ -3463,19 +4283,57 @@ public class DatagramChannelTest extends TestCase {
         ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
         assertEquals(0, this.channel2.read(targetBuf));
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer.class}
-              ),              
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
+    public void testReadWrite_NonBlock_Zero() throws Exception {
+        byte[] sourceArray = new byte[0];
+        byte[] targetArray = new byte[0];
+
+        this.channel1.configureBlocking(false);
+        this.channel2.configureBlocking(false);
+
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        // write
+        ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
+        assertEquals(0, this.channel1.write(sourceBuf));
+
+        // read
+        ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
+        assertEquals(0, this.channel2.read(targetBuf));
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "read",
+            args = {java.nio.ByteBuffer.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "write",
+            args = {java.nio.ByteBuffer.class}
+        )
+    })
     public void testReadWrite_NonBlock_ReaderNotBind() throws Exception {
         byte[] sourceArray = new byte[CAPACITY_NORMAL];
         byte[] targetArray = new byte[CAPACITY_NORMAL];
@@ -3499,36 +4357,94 @@ public class DatagramChannelTest extends TestCase {
         ByteBuffer targetBuf = ByteBuffer.wrap(targetArray);
         assertEquals(0, this.channel2.read(targetBuf));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_write_LBuffer_positioned() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testWriteByteBuffer_Positioned() throws Exception {
         // Regression test for Harmony-683
         int postion = 16;
         DatagramChannel dc = DatagramChannel.open();
-        byte[] sourceArray = new byte[CAPACITY_NORMAL];        
+        byte[] sourceArray = new byte[CAPACITY_NORMAL];
         dc.connect(localAddr1);
         // write
         ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
         sourceBuf.position(postion);
         assertEquals(CAPACITY_NORMAL - postion, dc.write(sourceBuf));
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "send",
-          methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-        )
-    })
-    public void test_send_LBuffer_LSocketAddress_PositonNotZero()
+
+    public void disabled_testWriteByteBuffer_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.send(targetBuf, localAddr1);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    public void disabled_testWriteByteBuffer_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends  Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+                    channel1.send(targetBuf, localAddr1);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
+    public void testSend_PositonNotZero()
             throws Exception {
         // regression test for Harmony-701
         int CAPACITY_NORMAL = 256;
@@ -3539,81 +4455,230 @@ public class DatagramChannelTest extends TestCase {
         ByteBuffer sourceBuf = ByteBuffer.wrap(sourceArray);
         sourceBuf.position(postion);
         int ret = dc.send(sourceBuf, localAddr1);
-        // assert send (256 - 16) bytes  
+        // assert send (256 - 16) bytes
         assertEquals(CAPACITY_NORMAL - postion, ret);
         // assert the position of ByteBuffer has been set
         assertEquals(CAPACITY_NORMAL, sourceBuf.position());
     }
-    
+
+    /**
+     * @tests DatagramChannel#read(ByteBuffer)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer2() throws Exception {
+        // regression test for Harmony-754
+        channel2.socket().bind(localAddr1);
+        channel1.socket().bind(localAddr2);
+        channel1.connect(localAddr1);
+        channel2.connect(localAddr2);
+        channel2.write(ByteBuffer.allocate(CAPACITY_NORMAL));
+
+        ByteBuffer readBuf = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+
+        channel1.configureBlocking(true);
+        assertEquals(CAPACITY_NORMAL, channel1.read(readBuf));
+    }
+
+    public void disabled_testReadByteBuffer_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.read(targetBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer_Block_interrupt() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer targetBuf = ByteBuffer.wrap(new byte[2]);
+                    channel1.read(targetBuf);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
     /**
      * @tests DatagramChannel#read(ByteBuffer[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
-    public void test_read_$LByteBuffer() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void testReadByteBufferArray2() throws Exception {
         // regression test for Harmony-754
         channel2.socket().bind(localAddr1);
         channel1.socket().bind(localAddr2);
-        channel1.connect(localAddr1);         
+        channel1.connect(localAddr1);
         channel2.connect(localAddr2);
         channel2.write(ByteBuffer.allocate(CAPACITY_NORMAL));
-        
+
         ByteBuffer[] readBuf = new ByteBuffer[2];
         readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);        
-        
+        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+
         channel1.configureBlocking(true);
         assertEquals(CAPACITY_NORMAL, channel1.read(readBuf));
     }
 
+    public void disabled_testReadByteBufferArray_Block_close() throws Exception {
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+        ByteBuffer[] targetBuf = new ByteBuffer[2];
+        targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+        targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.sleep(TIME_UNIT);
+                    channel1.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            this.channel1.read(targetBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    public void disabled_testReadByteBufferArray_Block_interrupt() throws Exception {
+        // makes emulator hang
+        // bind and connect
+        this.channel1.socket().bind(localAddr2);
+        this.channel1.connect(localAddr1);
+        this.channel2.socket().bind(localAddr1);
+        this.channel2.connect(localAddr2);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    ByteBuffer[] targetBuf = new ByteBuffer[2];
+                    targetBuf[0] = ByteBuffer.wrap(new byte[2]);
+                    targetBuf[1] = ByteBuffer.wrap(new byte[2]);
+                    channel1.read(targetBuf);
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (IOException e) {
+                    errMsg = "Unexcted Exception was thrown: " + e.getClass() +
+                            ": " + e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            // ok
+        }
+        thread.join(TIME_UNIT);
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
     /**
      * @tests DatagramChannel#read(ByteBuffer[],int,int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void test_read_$LByteBufferII() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void testReadByteBufferArrayII2() throws Exception {
         // regression test for Harmony-754
         channel2.socket().bind(localAddr1);
         channel1.socket().bind(localAddr2);
-        channel1.connect(localAddr1);         
+        channel1.connect(localAddr1);
         channel2.connect(localAddr2);
         channel2.write(ByteBuffer.allocate(CAPACITY_NORMAL));
-        
+
         ByteBuffer[] readBuf = new ByteBuffer[2];
         readBuf[0] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
-        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);        
-        
+        readBuf[1] = ByteBuffer.allocateDirect(CAPACITY_NORMAL);
+
         channel1.configureBlocking(true);
         assertEquals(CAPACITY_NORMAL, channel1.read(readBuf,0,2));
     }
-    
+
     /**
      * @tests DatagramChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_read_LByteBuffer_closed_nullBuf() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer_closed_nullBuf() throws Exception {
         // regression test for Harmony-754
         ByteBuffer c = null;
         DatagramChannel channel = DatagramChannel.open();
@@ -3625,20 +4690,17 @@ public class DatagramChannelTest extends TestCase {
             // expected
         }
     }
-    
+
     /**
      * @tests DatagramChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_read_LByteBuffer_NotConnected_nullBuf() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer_NotConnected_nullBuf() throws Exception {
         // regression test for Harmony-754
         ByteBuffer c = null;
         DatagramChannel channel = DatagramChannel.open();
@@ -3649,20 +4711,17 @@ public class DatagramChannelTest extends TestCase {
             // expected
         }
     }
-    
+
     /**
      * @tests DatagramChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_read_LByteBuffer_readOnlyBuf() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void testReadByteBuffer_readOnlyBuf() throws Exception {
         // regression test for Harmony-754
         ByteBuffer c = ByteBuffer.allocate(1);
         DatagramChannel channel = DatagramChannel.open();
@@ -3680,20 +4739,17 @@ public class DatagramChannelTest extends TestCase {
             // expected
         }
     }
-    
+
     /**
      * @tests DatagramChannel#send(ByteBuffer, SocketAddress)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "send",
-          methodArgs = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
-        )
-    })
-    public void test_send_LByteBuffer_LSocketAddress_closed() throws IOException{
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "send",
+        args = {java.nio.ByteBuffer.class, java.net.SocketAddress.class}
+    )
+    public void testSend_Closed() throws IOException{
         // regression test for Harmony-913
         channel1.close();
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
@@ -3722,20 +4778,17 @@ public class DatagramChannelTest extends TestCase {
             //pass
         }
     }
-    
+
     /**
      * @tests DatagramChannel#socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
-    public void test_socket_IllegalBlockingModeException() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
+    public void testSocket_NonBlock_IllegalBlockingModeException() throws Exception {
         // regression test for Harmony-1036
         DatagramChannel channel = DatagramChannel.open();
         channel.configureBlocking(false);
@@ -3753,69 +4806,4 @@ public class DatagramChannelTest extends TestCase {
             // expected
         }
     }
-    
-    // -------------------------------------------------------------------
-    // Mock class for security test.
-    // -------------------------------------------------------------------
-    private class MockSecurityManager extends SecurityManager {
-
-        String validHost = null;
-
-        int validPort = -1;
-
-        MockSecurityManager() {
-            super();
-            this.validHost = null;
-        }
-
-        MockSecurityManager(String host) {
-            super();
-            this.validHost = host;
-        }
-
-        MockSecurityManager(int port) {
-            super();
-            this.validPort = port;
-        }
-
-        public void checkPermission(Permission perm) {
-            // no-op
-        }
-
-        public void checkPermission(Permission perm, Object context) {
-            // no-op
-        }
-
-        public void checkConnect(String host, int port) {
-            // our local addr is OK.
-            if (null != this.validHost) {
-                if (!this.validHost.equals(host)) {
-                    throw new SecurityException();
-                }
-            }
-            if ("127.0.0.1".equals(host)) {
-                return;
-            }
-            super.checkConnect(host, port);
-        }
-
-        public void checkAccept(String host, int port) {
-            // our local addr is OK.
-            if (null != this.validHost) {
-                if (!this.validHost.equals(host)) {
-                    throw new SecurityException();
-                }
-            }
-            if (-1 != this.validPort) {
-                if (this.validPort != port) {
-                    throw new SecurityException();
-                }
-            }
-            if ("127.0.0.1".equals(host)) {
-                return;
-            }
-            super.checkAccept(host, port);
-        }
-    }
-
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelLockingTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelLockingTest.java
deleted file mode 100644
index 4d707c7..0000000
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelLockingTest.java
+++ /dev/null
@@ -1,254 +0,0 @@
-/* Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- * 
- *     http://www.apache.org/licenses/LICENSE-2.0
- * 
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.harmony.nio.tests.java.nio.channels;
-
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTargetClass;
-
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.FileOutputStream;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.io.RandomAccessFile;
-import java.nio.channels.FileChannel;
-import java.nio.channels.FileLock;
-import java.nio.channels.NonReadableChannelException;
-import java.nio.channels.NonWritableChannelException;
-import java.nio.channels.OverlappingFileLockException;
-
-import junit.framework.TestCase;
-
-/**
- * API tests for the NIO FileChannel locking APIs
- */
-@TestTargetClass(java.nio.channels.FileChannel.class)
-public class FileChannelLockingTest extends TestCase {
-
-    private FileChannel readOnlyChannel;
-
-    private FileChannel writeOnlyChannel;
-
-    private FileChannel readWriteChannel;
-
-    private final String CONTENT = "The best things in life are nearest: Breath in your nostrils, light in your eyes, "
-            + "flowers at your feet, duties at your hand, the path of right just before you. Then do not grasp at the stars, "
-            + "but do life's plain, common work as it comes, certain that daily duties and daily bread are the sweetest "
-            + " things in life.--Robert Louis Stevenson";
-
-    protected void setUp() throws Exception {
-        super.setUp();
-
-        // Create a three temporary files with content.
-        File[] tempFiles = new File[3];
-        for (int i = 0; i < tempFiles.length; i++) {
-            tempFiles[i] = File.createTempFile("testing", "tmp");
-            tempFiles[i].deleteOnExit();
-            FileWriter writer = new FileWriter(tempFiles[i]);
-            writer.write(CONTENT);
-            writer.close();
-        }
-
-        // Open read, write, and read/write channels on the temp files.
-        FileInputStream fileInputStream = new FileInputStream(tempFiles[0]);
-        readOnlyChannel = fileInputStream.getChannel();
-
-        FileOutputStream fileOutputStream = new FileOutputStream(tempFiles[1]);
-        writeOnlyChannel = fileOutputStream.getChannel();
-
-        RandomAccessFile randomAccessFile = new RandomAccessFile(tempFiles[2],
-                "rw");
-        readWriteChannel = randomAccessFile.getChannel();
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {}
-        ),
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
-    public void test_illegalLocks() throws IOException {
-        // Cannot acquire an exclusive lock on a read-only file channel
-        try {
-            readOnlyChannel.lock();
-            fail("Acquiring a full exclusive lock on a read only channel should fail.");
-        } catch (NonWritableChannelException ex) {
-            // Expected.
-        }
-
-        // Cannot get a shared lock on a write-only file channel.
-        try {
-            writeOnlyChannel.lock(1, 10, true);
-            fail("Acquiring a shared lock on a write-only channel should fail.");
-        } catch (NonReadableChannelException ex) {
-            // expected
-        }
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {}
-        )
-    })
-    public void test_lockReadWrite() throws IOException {
-        // Acquire an exclusive lock across the entire file.
-        FileLock flock = readWriteChannel.lock();
-        if (flock != null) {
-            flock.release();
-        }
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
-    public void test_illegalLockParameters() throws IOException {
-        // Cannot lock negative positions
-        try {
-            readOnlyChannel.lock(-1, 10, true);
-            fail("Passing illegal args to lock should fail.");
-        } catch (IllegalArgumentException ex) {
-            // expected
-        }
-        try {
-            writeOnlyChannel.lock(-1, 10, false);
-            fail("Passing illegal args to lock should fail.");
-        } catch (IllegalArgumentException ex) {
-            // expected
-        }
-        try {
-            readWriteChannel.lock(-1, 10, false);
-            fail("Passing illegal args to lock should fail.");
-        } catch (IllegalArgumentException ex) {
-            // expected
-        }
-
-        // Lock a range at the front, shared.
-        FileLock flock1 = readWriteChannel.lock(22, 110, true);
-
-        // Try to acquire an overlapping lock.
-        try {
-            readWriteChannel.lock(75, 210, true);
-        } catch (OverlappingFileLockException exception) {
-            // expected
-            flock1.release();
-        }
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't call isShared, isValid methods after lock.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
-    public void test_lockLLZ() throws IOException {
-        // Lock a range at the front, non-shared.
-        FileLock flock1 = readWriteChannel.lock(0, 10, false);
-
-        // Lock a shared range further in the same file.
-        FileLock flock2 = readWriteChannel.lock(22, 100, true);
-
-        // The spec allows the impl to refuse shared locks
-        flock1.release();
-        flock2.release();
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "tryLock",
-          methodArgs = {}
-        )
-    })
-    public void test_tryLock() throws IOException {
-        try {
-            readOnlyChannel.tryLock();
-            fail("Acquiring a full exclusive lock on a read channel should have thrown an exception.");
-        } catch (NonWritableChannelException ex) {
-            // Expected.
-        }
-    }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "tryLock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
-    public void test_tryLockLLZ() throws IOException {
-        // It is illegal to request an exclusive lock on a read-only channel
-        try {
-            readOnlyChannel.tryLock(0, 99, false);
-            fail("Acquiring exclusive lock on read-only channel should fail");
-        } catch (NonWritableChannelException ex) {
-            // Expected
-        }
-
-        // It is invalid to request a lock starting before the file start
-        try {
-            readOnlyChannel.tryLock(-99, 0, true);
-            fail("Acquiring an illegal lock value should fail.");
-        } catch (IllegalArgumentException ex) {
-            // expected
-        }
-
-        // Acquire a valid lock
-        FileLock tmpLock = readOnlyChannel.tryLock(0, 10, true);
-        assertTrue(tmpLock.isValid());
-        tmpLock.release();
-
-        // Acquire another valid lock -- and don't release it yet
-        FileLock lock = readOnlyChannel.tryLock(10, 788, true);
-        assertTrue(lock.isValid());
-
-        // Overlapping locks are illegal
-        try {
-            readOnlyChannel.tryLock(1, 23, true);
-            fail("Acquiring an overlapping lock should fail.");
-        } catch (OverlappingFileLockException ex) {
-            // Expected
-        }
-
-        // Adjacent locks are legal
-        FileLock adjacentLock = readOnlyChannel.tryLock(1, 3, true);
-        assertTrue(adjacentLock.isValid());
-        adjacentLock.release();
-
-        // Release longer lived lock
-        lock.release();
-    }
-}
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelTest.java
index 68c8223..9a1a956 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileChannelTest.java
@@ -4,9 +4,9 @@
  * The ASF licenses this file to You under the Apache License, Version 2.0
  * (the "License"); you may not use this file except in compliance with
  * the License.  You may obtain a copy of the License at
- * 
+ *
  *     http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
@@ -16,8 +16,9 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.AndroidOnly;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -52,13 +53,23 @@ import org.apache.harmony.luni.platform.Platform;
 
 import junit.framework.TestCase;
 
-@TestTargetClass(FileChannel.class)
+@TestTargetClass(
+    value = FileChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "FileChannel",
+            args = {}
+        )
+    }
+)
 public class FileChannelTest extends TestCase {
 
     private static final int CAPACITY = 100;
 
     private static final int LIMITED_CAPACITY = 2;
-    
+
     private static final int TIME_OUT = 10000;
 
     private static final String CONTENT = "MYTESTSTRING needs to be a little long";
@@ -90,7 +101,7 @@ public class FileChannelTest extends TestCase {
     private File fileOfWriteOnlyFileChannel;
 
     private File fileOfReadWriteFileChannel;
-    
+
     private ReadableByteChannel readByteChannel;
 
     private WritableByteChannel writableByteChannel;
@@ -235,16 +246,13 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#force(boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify force method with false parameter.",
-      targets = {
-        @TestTarget(
-          methodName = "force",
-          methodArgs = {boolean.class}
-        )
-    })
-    public void test_forceJ() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "force",
+        args = {boolean.class}
+    )
+    public void test_forceZ() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
         writeOnlyFileChannel.write(writeBuffer);
         writeOnlyFileChannel.force(true);
@@ -253,21 +261,26 @@ public class FileChannelTest extends TestCase {
         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
         fis.read(readBuffer);
         assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
+
+        writeOnlyFileChannel.write(writeBuffer);
+        writeOnlyFileChannel.force(false);
+
+        readBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
+        fis = new FileInputStream(fileOfWriteOnlyFileChannel);
+        fis.read(readBuffer);
+        assertTrue(Arrays.equals(CONTENT_AS_BYTES, readBuffer));
     }
 
     /**
      * @tests java.nio.channels.FileChannel#force(boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "force",
-          methodArgs = {boolean.class}
-        )
-    })
-    public void test_forceJ_closed() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "force",
+        args = {boolean.class}
+    )
+    public void test_forceZ_closed() throws Exception {
         writeOnlyFileChannel.close();
         try {
             writeOnlyFileChannel.force(true);
@@ -287,16 +300,13 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#force(boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "force",
-          methodArgs = {boolean.class}
-        )
-    })
-    public void test_forceJ_ReadOnlyChannel() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "force",
+        args = {boolean.class}
+    )
+    public void test_forceZ_ReadOnlyChannel() throws Exception {
         // force on a read only file channel has no effect.
         readOnlyFileChannel.force(true);
         readOnlyFileChannel.force(false);
@@ -305,15 +315,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position_Init() throws Exception {
         assertEquals(0, readOnlyFileChannel.position());
         assertEquals(0, writeOnlyFileChannel.position());
@@ -323,15 +330,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position_ReadOnly() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
 
@@ -343,7 +347,7 @@ public class FileChannelTest extends TestCase {
 
     /**
      * Initializes test file.
-     * 
+     *
      * @param file
      * @throws FileNotFoundException
      * @throws IOException
@@ -360,14 +364,14 @@ public class FileChannelTest extends TestCase {
 
     /**
      * Initializes large test file.
-     * 
+     *
      * @param file the file to be written
      * @param size the content size to be written
      * @throws FileNotFoundException
      * @throws IOException
      */
-    private void writeLargeDataToFile(File file, int size) throws FileNotFoundException,
-            IOException {
+    private void writeLargeDataToFile(File file, int size) 
+            throws FileNotFoundException, IOException {
         FileOutputStream fos = new FileOutputStream(file);
         byte[] buf = new byte[size];
 
@@ -382,15 +386,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position_WriteOnly() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
         writeOnlyFileChannel.write(writeBuffer);
@@ -400,15 +401,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position_ReadWrite() throws Exception {
         writeDataToFile(fileOfReadWriteFileChannel);
 
@@ -425,15 +423,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "position",
+        args = {}
+    )
     public void test_position_Closed() throws Exception {
         readOnlyFileChannel.close();
         try {
@@ -463,15 +458,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "position",
+        args = {long.class}
+    )
     public void test_positionJ_Closed() throws Exception {
         final long POSITION = 100;
 
@@ -503,15 +495,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position(long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "Verifies IllegalArgumentException.",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "position",
+        args = {long.class}
+    )
     public void test_positionJ_Negative() throws Exception {
         final long NEGATIVE_POSITION = -1;
         try {
@@ -539,15 +528,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position(long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {long.class}
+    )
     public void test_positionJ_ReadOnly() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
 
@@ -572,15 +558,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position(long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "position",
-                  methodArgs = {long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {long.class}
+    )
     public void test_positionJ_WriteOnly() throws Exception {
         writeDataToFile(fileOfWriteOnlyFileChannel);
 
@@ -615,15 +598,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#size()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies zero size.",
-      targets = {
-        @TestTarget(
-          methodName = "size",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies zero size.",
+        method = "size",
+        args = {}
+    )
     public void test_size_Init() throws Exception {
         assertEquals(0, readOnlyFileChannel.size());
         assertEquals(0, writeOnlyFileChannel.size());
@@ -633,15 +613,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#size()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies positive case.",
-      targets = {
-        @TestTarget(
-          methodName = "size",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies positive case.",
+        method = "size",
+        args = {}
+    )
     public void test_size() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         assertEquals(fileOfReadOnlyFileChannel.length(), readOnlyFileChannel
@@ -651,15 +628,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#size()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "size",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "size",
+        args = {}
+    )
     public void test_size_Closed() throws Exception {
         readOnlyFileChannel.close();
         try {
@@ -689,15 +663,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#truncate(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "truncate",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "truncate",
+        args = {long.class}
+    )
     public void test_truncateJ_Closed() throws Exception {
         readOnlyFileChannel.close();
         try {
@@ -727,15 +698,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#truncate(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "truncate",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "truncate",
+        args = {long.class}
+    )
     public void test_truncateJ_IllegalArgument() throws Exception {
         // regression test for Harmony-941
         try {
@@ -744,7 +712,7 @@ public class FileChannelTest extends TestCase {
         } catch (IllegalArgumentException e) {
             // expected
         }
-        
+
         try {
             writeOnlyFileChannel.truncate(-1);
             fail("should throw IllegalArgumentException");
@@ -763,15 +731,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#truncate(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies NonWritableChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "truncate",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException.",
+        method = "truncate",
+        args = {long.class}
+    )
     public void test_truncateJ_ReadOnly() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         try {
@@ -792,15 +757,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#truncate(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Doesn't verify exceptions.",
-      targets = {
-        @TestTarget(
-          methodName = "truncate",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exceptions.",
+        method = "truncate",
+        args = {long.class}
+    )
     public void test_truncateJ() throws Exception {
         writeDataToFile(fileOfReadWriteFileChannel);
 
@@ -823,15 +785,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "lock",
+        args = {}
+    )
     public void test_lock() throws Exception {
         MockFileChannel mockFileChannel = new MockFileChannel();
         // Verify that calling lock() leads to the method
@@ -845,15 +804,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_Closed() throws Exception {
         readOnlyFileChannel.close();
         try {
@@ -891,15 +847,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_IllegalArgument() throws Exception {
         try {
             writeOnlyFileChannel.lock(0, -1, false);
@@ -933,15 +886,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NonWritableChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_NonWritable() throws Exception {
         try {
             readOnlyFileChannel.lock(0, 10, false);
@@ -962,15 +912,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NonReadableChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonReadableChannelException.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_NonReadable() throws Exception {
         try {
             writeOnlyFileChannel.lock(0, 10, true);
@@ -991,15 +938,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies shared channel.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies shared channel.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_Shared() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1016,15 +960,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that unshared channel.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that unshared channel.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_NotShared() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1039,15 +980,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies lok method with Long max value as a size.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies lock method with Long max value as a size.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_Long_MAX_VALUE() throws Exception {
         final long POSITION = 0;
         final long SIZE = Long.MAX_VALUE;
@@ -1062,15 +1000,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies OverlappingFileLockException.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies OverlappingFileLockException.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_Overlapping() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1088,15 +1023,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long, long, boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that not overlaping regions can be locked.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that not overlaping regions can be locked.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_NotOverlapping() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1110,15 +1042,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#lock(long,long,boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies functionality after release method.",
-      targets = {
-        @TestTarget(
-          methodName = "lock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies functionality after release method.",
+        method = "lock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_lockJJZ_After_Release() throws Exception {
         fileLock = writeOnlyFileChannel.lock(0, 10, false);
         fileLock.release();
@@ -1130,15 +1059,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "tryLock",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {}
+    )
     public void test_tryLock() throws Exception {
         MockFileChannel mockFileChannel = new MockFileChannel();
         // Verify that calling tryLock() leads to the method
@@ -1152,15 +1078,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_Closed() throws Exception {
         readOnlyFileChannel.close();
         try {
@@ -1198,15 +1121,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies IllegalArgumentException.",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_IllegalArgument() throws Exception {
         try {
             writeOnlyFileChannel.tryLock(0, -1, false);
@@ -1240,15 +1160,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NonWritableChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException.",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_NonWritable() throws Exception {
         try {
             readOnlyFileChannel.tryLock(0, 10, false);
@@ -1269,15 +1186,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NonReadableChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonReadableChannelException.",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_NonReadable() throws Exception {
         try {
             writeOnlyFileChannel.tryLock(0, 10, true);
@@ -1298,15 +1212,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_Shared() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1323,15 +1234,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_NotShared() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1346,15 +1254,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_Long_MAX_VALUE() throws Exception {
         final long POSITION = 0;
         final long SIZE = Long.MAX_VALUE;
@@ -1369,15 +1274,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies OverlappingFileLockException.",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies OverlappingFileLockException.",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_Overlapping() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1395,15 +1297,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long, long, boolean)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "tryLock",
-                  methodArgs = {long.class, long.class, boolean.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_NotOverlapping() throws Exception {
         final long POSITION = 100;
         final long SIZE = 200;
@@ -1419,15 +1318,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#tryLock(long,long,boolean)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "tryLock",
-          methodArgs = {long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "tryLock",
+        args = {long.class, long.class, boolean.class}
+    )
     public void test_tryLockJJZ_After_Release() throws Exception {
         fileLock = writeOnlyFileChannel.tryLock(0, 10, false);
         fileLock.release();
@@ -1440,15 +1336,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NullPointerException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer_Null() throws Exception {
         ByteBuffer readBuffer = null;
 
@@ -1470,17 +1363,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException. Doesn't verify " +
-            "AsynchronousCloseException, ClosedByInterruptException, " +
-            "IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer_Closed() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -1511,6 +1399,20 @@ public class FileChannelTest extends TestCase {
         // should throw ClosedChannelException first
         readBuffer = null;
         try {
+            readOnlyFileChannel.read(readBuffer);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+
+        try {
+            writeOnlyFileChannel.read(readBuffer);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+
+        try {
             readWriteFileChannel.read(readBuffer);
             fail("should throw ClosedChannelException");
         } catch (ClosedChannelException e) {
@@ -1521,15 +1423,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NonReadableChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonReadableChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer_WriteOnly() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -1553,15 +1452,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer_EmptyFile() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
         int result = readOnlyFileChannel.read(readBuffer);
@@ -1572,15 +1468,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer_LimitedCapacity() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
 
@@ -1597,15 +1490,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_readLByteBuffer() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
 
@@ -1622,15 +1512,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer, long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NullPointerException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_Null() throws Exception {
         ByteBuffer readBuffer = null;
 
@@ -1649,8 +1536,21 @@ public class FileChannelTest extends TestCase {
             // expected
         }
 
+        try {
+            readWriteFileChannel.read(readBuffer, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
         // first throws NullPointerException
-        writeOnlyFileChannel.close();
+        try {
+            readWriteFileChannel.read(readBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
         try {
             writeOnlyFileChannel.read(readBuffer, 0);
             fail("should throw NullPointerException");
@@ -1658,8 +1558,9 @@ public class FileChannelTest extends TestCase {
             // expected
         }
 
+        // first throws NullPointerException
         try {
-            readWriteFileChannel.read(readBuffer, 0);
+            writeOnlyFileChannel.read(readBuffer, -1);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
@@ -1673,20 +1574,54 @@ public class FileChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // expected
         }
+
+        try {
+            writeOnlyFileChannel.read(readBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        readWriteFileChannel.close();
+        try {
+            readWriteFileChannel.read(readBuffer, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        try {
+            readWriteFileChannel.read(readBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.read(readBuffer, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        try {
+            readOnlyFileChannel.read(readBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
     }
 
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer, long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_Closed() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -1710,15 +1645,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer, long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_IllegalArgument() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -1744,6 +1676,22 @@ public class FileChannelTest extends TestCase {
         }
 
         // throws IllegalArgumentException first.
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.read(readBuffer, -1);
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.read(readBuffer, -1);
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+
         readWriteFileChannel.close();
         try {
             readWriteFileChannel.read(readBuffer, -1);
@@ -1756,15 +1704,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer, long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonReadableChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_WriteOnly() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -1788,15 +1733,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_Emptyfile() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
         int result = readOnlyFileChannel.read(readBuffer, 0);
@@ -1807,15 +1749,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_Postion_BeyondFileLimit()
             throws Exception {
 
@@ -1831,15 +1770,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IOException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IOException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ_Postion_As_Long() throws Exception {
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
         try {
@@ -1852,15 +1788,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_readLByteBufferJ() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         ByteBuffer readBuffer = ByteBuffer.allocate(CAPACITY);
@@ -1879,26 +1812,23 @@ public class FileChannelTest extends TestCase {
             assertEquals(CONTENT_AS_BYTES[i], readBuffer.get());
         }
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
-    public void test_read$LByteBuffer() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_read$LByteBuffer_Regression() throws Exception {
         // regression test for Harmony-849
         writeDataToFile(fileOfReadOnlyFileChannel);
         ByteBuffer[] readBuffers = new ByteBuffer[2];
         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
         readBuffers[1] = ByteBuffer.allocate(CAPACITY);
-        
+
         long readCount = readOnlyFileChannel.read(readBuffers);
         assertEquals(CONTENT_AS_BYTES_LENGTH, readCount);
         assertEquals(CONTENT_AS_BYTES_LENGTH, readBuffers[0].position());
@@ -1908,20 +1838,17 @@ public class FileChannelTest extends TestCase {
             assertEquals(CONTENT_AS_BYTES[i], readBuffers[0].get());
         }
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
-    public void test_read$LByteBuffer_mock() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_read$LByteBuffer() throws Exception {
         FileChannel mockChannel = new MockFileChannel();
         ByteBuffer[] buffers = new ByteBuffer[2];
         mockChannel.read(buffers);
@@ -1933,50 +1860,199 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_Null() throws Exception {
-        ByteBuffer[] readBuffers = null;
 
         try {
-            readOnlyFileChannel.read(readBuffers, 0, 1);
+            readOnlyFileChannel.read(null, 0, 1);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
         }
-
         try {
-            readOnlyFileChannel.read(readBuffers, 1, 11);
+            readOnlyFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 3, 0);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
         }
 
         try {
-            writeOnlyFileChannel.read(readBuffers, 0, 1);
+            writeOnlyFileChannel.read(null, 0, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 3, 0);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
         }
 
         try {
-            readWriteFileChannel.read(readBuffers, 0, 1);
+            readWriteFileChannel.read(null, 0, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 3, 0);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
         }
 
         // first throws NullPointerException
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.read(null, 0, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.read(null, 3, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        readWriteFileChannel.close();
+        try {
+            readWriteFileChannel.read(null, 0, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.read(null, 3, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
         writeOnlyFileChannel.close();
         try {
-            writeOnlyFileChannel.read(readBuffers, 0, 1);
+            writeOnlyFileChannel.read(null, 0, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 0, 3);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 2, 1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.read(null, 3, 0);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
@@ -1986,15 +2062,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_Closed() throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
@@ -2022,7 +2095,7 @@ public class FileChannelTest extends TestCase {
         } catch (ClosedChannelException e) {
             // expected
         }
-        
+
         // regression test for Harmony-902
         readBuffers[0] = null;
         try {
@@ -2048,15 +2121,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_WriteOnly() throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
@@ -2078,25 +2148,75 @@ public class FileChannelTest extends TestCase {
         }
     }
 
+    private void doTestForIOOBException(FileChannel channel, 
+            ByteBuffer[] buffer) throws IOException{
+        try {
+            channel.read(buffer, -1, 0);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            channel.read(buffer, 0, -1);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            channel.read(buffer, 0, 3);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            channel.read(buffer, 1, 2);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            channel.read(buffer, 2, 1);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            channel.read(buffer, 3, 0);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+    }
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IndexOutOfBoundsException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_IndexOutOfBound() throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
         readBuffers[1] = ByteBuffer.allocate(CAPACITY);
+        ByteBuffer[] readBuffersNull = new ByteBuffer[2];
 
+        doTestForIOOBException(readOnlyFileChannel, readBuffers);
+        doTestForIOOBException(readWriteFileChannel, readBuffers);
+        doTestForIOOBException(writeOnlyFileChannel, readBuffers);
+        
+        doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
+        doTestForIOOBException(readWriteFileChannel, readBuffersNull);
+        doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
+        try {
+            readOnlyFileChannel.read(null, -1, 0);
+            fail("should throw IndexOutOfBoundException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
         try {
-            readOnlyFileChannel.read(readBuffers, 2, 1);
+            readOnlyFileChannel.read(null, 0, -1);
             fail("should throw IndexOutOfBoundException");
         } catch (IndexOutOfBoundsException e) {
             // expected
@@ -2104,47 +2224,52 @@ public class FileChannelTest extends TestCase {
 
         try {
             readWriteFileChannel.read(null, -1, 0);
-            fail("should throw IndexOutOfBoundsException");
+            fail("should throw IndexOutOfBoundException");
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-
         try {
-            writeOnlyFileChannel.read(readBuffers, 0, 3);
-            fail("should throw IndexOutOfBoundsException");
+            readWriteFileChannel.read(null, 0, -1);
+            fail("should throw IndexOutOfBoundException");
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
 
         try {
-            readWriteFileChannel.read(readBuffers, -1, 0);
-            fail("should throw IndexOutOfBoundsException");
+            writeOnlyFileChannel.read(null, -1, 0);
+            fail("should throw IndexOutOfBoundException");
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-
-        // throws IndexOutOfBoundsException first
-        readWriteFileChannel.close();
         try {
-            readWriteFileChannel.read(readBuffers, 0, 3);
-            fail("should throw IndexOutOfBoundsException");
+            writeOnlyFileChannel.read(null, 0, -1);
+            fail("should throw IndexOutOfBoundException");
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
+
+        readOnlyFileChannel.close();
+        doTestForIOOBException(readOnlyFileChannel, readBuffers);
+        doTestForIOOBException(readOnlyFileChannel, readBuffersNull);
+
+        readWriteFileChannel.close();
+        doTestForIOOBException(readWriteFileChannel, readBuffers);
+        doTestForIOOBException(readWriteFileChannel, readBuffersNull);
+
+        writeOnlyFileChannel.close();
+        doTestForIOOBException(writeOnlyFileChannel, readBuffers);
+        doTestForIOOBException(writeOnlyFileChannel, readBuffersNull);
     }
 
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_EmptyFile() throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
         readBuffers[0] = ByteBuffer.allocate(CAPACITY);
@@ -2158,17 +2283,16 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NullPointerException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_EmptyBuffers() throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
+        readBuffers[0] = ByteBuffer.allocate(CAPACITY);
+
         try {
             readOnlyFileChannel.read(readBuffers, 0, 2);
         } catch (NullPointerException e) {
@@ -2190,15 +2314,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_EmptyFile_EmptyBuffers()
             throws Exception {
         ByteBuffer[] readBuffers = new ByteBuffer[2];
@@ -2210,15 +2331,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_Length_Zero() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         ByteBuffer[] readBuffers = new ByteBuffer[2];
@@ -2231,15 +2349,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII_LimitedCapacity() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         ByteBuffer[] readBuffers = new ByteBuffer[2];
@@ -2257,19 +2372,16 @@ public class FileChannelTest extends TestCase {
             assertEquals(CONTENT_AS_BYTES[i], readBuffers[1].get());
         }
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_read$LByteBufferII() throws Exception {
         writeDataToFile(fileOfReadOnlyFileChannel);
         ByteBuffer[] readBuffers = new ByteBuffer[2];
@@ -2290,14 +2402,20 @@ public class FileChannelTest extends TestCase {
 
     /**
      * @tests java.nio.channels.FileChannel#isOpen()
+     * @tests java.nio.channels.FileChannel#close()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Regression test. Doesn't verify that isOpen returns true.",
-      targets = {
-        @TestTarget(
-          methodName = "isOpen",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "isOpen",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
         )
     })
     public void test_isOpen() throws Exception {
@@ -2307,6 +2425,7 @@ public class FileChannelTest extends TestCase {
         FileOutputStream out = new FileOutputStream(logFile, true);
         FileChannel channel = out.getChannel();
         out.write(1);
+        assertTrue("Assert 0: Channel is not open", channel.isOpen());
         out.close();
         assertFalse("Assert 0: Channel is still open", channel.isOpen());
     }
@@ -2314,15 +2433,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#position()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position_append() throws Exception {
         // Regression test for Harmony-508
         File tmpfile = File.createTempFile("FileOutputStream", "tmp");
@@ -2340,22 +2456,16 @@ public class FileChannelTest extends TestCase {
         assertEquals(10, f.getChannel().position());
     }
 
-    
+
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies NonReadableChannelException, " +
-            "NonWritableChannelException , ClosedChannelException, " +
-            "IllegalArgumentException, IOException. ",
-      targets = {
-        @TestTarget(
-          methodName = "map",
-          methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                        long.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonReadableChannelException, NonWritableChannelException , ClosedChannelException, IllegalArgumentException, IOException. ",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_AbnormalMode() throws IOException {
         try {
             writeOnlyFileChannel.map(MapMode.READ_ONLY, 0, CONTENT_LENGTH);
@@ -2443,20 +2553,16 @@ public class FileChannelTest extends TestCase {
             // expected;
         }
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_ReadOnly_CloseChannel() throws IOException {
         // close channel has no effect on map if mapped
         assertEquals(0, readWriteFileChannel.size());
@@ -2470,16 +2576,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_Private_CloseChannel() throws IOException {
         MappedByteBuffer mapped = readWriteFileChannel.map(MapMode.PRIVATE, 0,
                 CONTENT_LENGTH);
@@ -2492,16 +2594,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_ReadOnly() throws IOException {
         MappedByteBuffer mapped = null;
         // try put something to readonly map
@@ -2533,16 +2631,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_ReadOnly_NonZeroPosition() throws IOException {
         this.writeDataToFile(fileOfReadOnlyFileChannel);
         MappedByteBuffer mapped = readOnlyFileChannel.map(MapMode.READ_ONLY,
@@ -2555,16 +2649,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_Private() throws IOException {
         this.writeDataToFile(fileOfReadWriteFileChannel);
         MappedByteBuffer mapped = readWriteFileChannel.map(MapMode.PRIVATE, 0,
@@ -2590,16 +2680,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_Private_NonZeroPosition() throws IOException {
         MappedByteBuffer mapped = readWriteFileChannel.map(MapMode.PRIVATE, 10,
                 CONTENT_LENGTH - 10);
@@ -2611,16 +2697,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_ReadWrite() throws IOException {
         MappedByteBuffer mapped = null;
         writeDataToFile(fileOfReadWriteFileChannel);
@@ -2648,16 +2730,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, 
-                                long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
     public void test_map_ReadWrite_NonZeroPosition() throws IOException {
         // test position non-zero
         writeDataToFile(fileOfReadWriteFileChannel);
@@ -2680,15 +2758,13 @@ public class FileChannelTest extends TestCase {
      *
      * @tests java.nio.channels.FileChannel#map(MapMode,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "map",
-                  methodArgs = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "map",
+        args = {java.nio.channels.FileChannel.MapMode.class, long.class, long.class}
+    )
+    @AndroidOnly("Platform.class is harmony specific")
     public void test_map_LargePosition() throws IOException {
         // Regression test for HARMONY-3085
         int[] sizes = {
@@ -2705,11 +2781,12 @@ public class FileChannelTest extends TestCase {
                 fileOfReadOnlyFileChannel = File.createTempFile(
                         "File_of_readOnlyFileChannel", "tmp");
                 fileOfReadOnlyFileChannel.deleteOnExit();
-                readOnlyFileChannel = new FileInputStream(fileOfReadOnlyFileChannel)
-                        .getChannel();
+                readOnlyFileChannel = new FileInputStream(
+                        fileOfReadOnlyFileChannel).getChannel();
             }
 
-            writeLargeDataToFile(fileOfReadOnlyFileChannel, sizes[i] + 2 * CONTENT_LEN);
+            writeLargeDataToFile(fileOfReadOnlyFileChannel, sizes[i] + 
+                    2 * CONTENT_LEN);
             MappedByteBuffer mapped = readOnlyFileChannel.map(MapMode.READ_ONLY,
                     sizes[i], CONTENT_LEN);
             assertEquals("Incorrectly mapped file channel for " + sizes[i]
@@ -2731,15 +2808,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_writeLByteBuffer_Null() throws Exception {
         ByteBuffer writeBuffer = null;
 
@@ -2761,15 +2835,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_writeLByteBuffer_Closed() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -2805,20 +2876,32 @@ public class FileChannelTest extends TestCase {
         } catch (ClosedChannelException e) {
             // expected
         }
+
+        try {
+            readOnlyFileChannel.write(writeBuffer);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.write(writeBuffer);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NonWritableChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_writeLByteBuffer_ReadOnly() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -2842,15 +2925,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_writeLByteBuffer() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
 
@@ -2867,20 +2947,17 @@ public class FileChannelTest extends TestCase {
         fis.read(inputBuffer);
         assertTrue(Arrays.equals(CONTENT_AS_BYTES, inputBuffer));
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class}
-                )
-            })
-    public void test_writeLByteBuffer_positioned() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void test_writeLByteBuffer_NonZeroPosition() throws Exception {
         final int pos = 5;
         ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
         writeBuffer.position(pos);
@@ -2895,22 +2972,19 @@ public class FileChannelTest extends TestCase {
         fis = new FileInputStream(fileOfWriteOnlyFileChannel);
         byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH - pos];
         fis.read(inputBuffer);
-        String test = CONTENT.substring(pos);        
+        String test = CONTENT.substring(pos);
         assertTrue(Arrays.equals(test.getBytes(), inputBuffer));
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer, long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NullPointerException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_writeLByteBufferJ_Null() throws Exception {
         ByteBuffer writeBuffer = null;
 
@@ -2921,6 +2995,14 @@ public class FileChannelTest extends TestCase {
             // expected
         }
 
+        // first throws NullPointerException
+        try {
+            readOnlyFileChannel.write(writeBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
         try {
             writeOnlyFileChannel.write(writeBuffer, 0);
             fail("should throw NullPointerException");
@@ -2930,7 +3012,7 @@ public class FileChannelTest extends TestCase {
 
         // first throws NullPointerException
         try {
-            readOnlyFileChannel.write(writeBuffer, -1);
+            writeOnlyFileChannel.write(writeBuffer, -1);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
@@ -2944,6 +3026,14 @@ public class FileChannelTest extends TestCase {
         }
 
         // first throws NullPointerException
+        try {
+            readWriteFileChannel.write(writeBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        // first throws NullPointerException
         readWriteFileChannel.close();
         try {
             readWriteFileChannel.write(writeBuffer, 0);
@@ -2951,20 +3041,54 @@ public class FileChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // expected
         }
+
+        try {
+            readWriteFileChannel.write(writeBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.write(writeBuffer, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        try {
+            writeOnlyFileChannel.write(writeBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.write(writeBuffer, 0);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        try {
+            readOnlyFileChannel.write(writeBuffer, -1);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer, long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_writeLByteBufferJ_Closed() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -2988,15 +3112,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer, long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NonWritableChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_writeLByteBufferJ_ReadOnly() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -3006,9 +3127,9 @@ public class FileChannelTest extends TestCase {
         } catch (NonWritableChannelException e) {
             // expected
         }
- 
+
         // regression test for Harmony-903
-        
+
         // read-only file channel never throws ClosedChannelException even if
         // the channel is closed.
         readOnlyFileChannel.close();
@@ -3032,21 +3153,36 @@ public class FileChannelTest extends TestCase {
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
-        } 
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.FileChannel#read(ByteBuffer,long)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IOException.",
+        method = "read",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
+    public void test_writeLByteBufferJ_Postion_As_Long() throws Exception {
+        ByteBuffer writeBuffer = ByteBuffer.wrap(TEST_BYTES);
+        try {
+            writeOnlyFileChannel.write(writeBuffer, Long.MAX_VALUE);
+        } catch (IOException e) {
+            // expected
+        }
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer, long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies IllegalArgumentException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_writeLByteBufferJ_IllegalArgument() throws Exception {
         ByteBuffer writeBuffer = ByteBuffer.allocate(CAPACITY);
 
@@ -3072,6 +3208,22 @@ public class FileChannelTest extends TestCase {
         }
 
         // throws IllegalArgumentException first.
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.write(writeBuffer, -1);
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.write(writeBuffer, -1);
+            fail("should throw IllegalArgumentException");
+        } catch (IllegalArgumentException e) {
+            // expected
+        }
+
         readWriteFileChannel.close();
         try {
             readWriteFileChannel.write(writeBuffer, -1);
@@ -3084,15 +3236,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
     public void test_writeLByteBufferJ() throws Exception {
         writeDataToFile(fileOfWriteOnlyFileChannel);
 
@@ -3117,38 +3266,165 @@ public class FileChannelTest extends TestCase {
     }
 
     /**
+     * @tests java.nio.channels.FileChannel#write(ByteBuffer)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class, long.class}
+    )
+    public void test_writeLByteBufferJ_NonZeroPosition() throws Exception {
+        final int pos = 5;
+        ByteBuffer writeBuffer = ByteBuffer.wrap(CONTENT_AS_BYTES);
+        writeBuffer.position(pos);
+        int result = writeOnlyFileChannel.write(writeBuffer, pos);
+        assertEquals(CONTENT_AS_BYTES_LENGTH - pos, result);
+        assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffer.position());
+        writeOnlyFileChannel.close();
+
+        assertEquals(CONTENT_AS_BYTES_LENGTH, fileOfWriteOnlyFileChannel
+                .length());
+
+        fis = new FileInputStream(fileOfWriteOnlyFileChannel);
+        byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH - pos];
+        fis.skip(pos);
+        fis.read(inputBuffer);
+        String test = CONTENT.substring(pos);
+        assertTrue(Arrays.equals(test.getBytes(), inputBuffer));
+    }
+
+    /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[])
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_write$LByteBuffer_Closed() throws Exception {
+        ByteBuffer[] writeBuffers = new ByteBuffer[2];
+        writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
+        writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
+
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.write(writeBuffers);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.write(writeBuffers);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+
+        readWriteFileChannel.close();
+        try {
+            readWriteFileChannel.write(writeBuffers);
+            fail("should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.FileChannel#write(ByteBuffer[])
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_write$LByteBuffer_ReadOnly() throws Exception {
+        ByteBuffer[] writeBuffers = new ByteBuffer[2];
+        writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
+        writeBuffers[1] = ByteBuffer.allocate(CAPACITY);
+
+        try {
+            readOnlyFileChannel.write(writeBuffers);
+            fail("should throw NonWritableChannelException");
+        } catch (NonWritableChannelException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.FileChannel#write(ByteBuffer[])
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_write$LByteBuffer_EmptyBuffers() throws Exception {
+        ByteBuffer[] writeBuffers = new ByteBuffer[2];
+        writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
+        try {
+            writeOnlyFileChannel.write(writeBuffers);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        try {
+            readWriteFileChannel.write(writeBuffers);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.FileChannel#write(ByteBuffer[])
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void test_write$LByteBuffer() throws Exception {
         ByteBuffer[] writeBuffers = new ByteBuffer[2];
-        MockFileChannel mockFileChannel = new MockFileChannel();
-        mockFileChannel.write(writeBuffers);
-        // verify that calling write(ByteBuffer[] srcs) leads to the method
-        // write(srcs, 0, srcs.length)
-        assertTrue(mockFileChannel.isWriteCalled);
+        writeBuffers[0] = ByteBuffer.wrap(CONTENT_AS_BYTES);
+        writeBuffers[1] = ByteBuffer.wrap(CONTENT_AS_BYTES);
+
+        long result = writeOnlyFileChannel.write(writeBuffers);
+        assertEquals(CONTENT_AS_BYTES_LENGTH * 2, result);
+        assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[0].position());
+        assertEquals(CONTENT_AS_BYTES_LENGTH, writeBuffers[1].position());
+        writeOnlyFileChannel.close();
+
+        assertEquals(CONTENT_AS_BYTES_LENGTH * 2, fileOfWriteOnlyFileChannel
+                .length());
+
+        fis = new FileInputStream(fileOfWriteOnlyFileChannel);
+        byte[] inputBuffer = new byte[CONTENT_AS_BYTES_LENGTH];
+        fis.read(inputBuffer);
+        byte[] expectedResult = new byte[CONTENT_AS_BYTES_LENGTH * 2];
+        System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult, 0,
+                CONTENT_AS_BYTES_LENGTH);
+        System.arraycopy(CONTENT_AS_BYTES, 0, expectedResult,
+                CONTENT_AS_BYTES_LENGTH, CONTENT_AS_BYTES_LENGTH);
+        assertTrue(Arrays.equals(CONTENT_AS_BYTES, inputBuffer));
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NullPointerException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_write$LByteBufferII_Null() throws Exception {
         ByteBuffer[] writeBuffers = null;
 
@@ -3174,9 +3450,25 @@ public class FileChannelTest extends TestCase {
         }
 
         // first throws NullPointerException
+        readOnlyFileChannel.close();
+        try {
+            readOnlyFileChannel.write(writeBuffers, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
+        writeOnlyFileChannel.close();
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 1, 2);
+            fail("should throw NullPointerException");
+        } catch (NullPointerException e) {
+            // expected
+        }
+
         readWriteFileChannel.close();
         try {
-            readWriteFileChannel.write(writeBuffers, 0, 0);
+            readWriteFileChannel.write(writeBuffers, 1, 2);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
@@ -3186,15 +3478,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_write$LByteBufferII_Closed() throws Exception {
         ByteBuffer[] writeBuffers = new ByteBuffer[2];
         writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
@@ -3223,30 +3512,17 @@ public class FileChannelTest extends TestCase {
         } catch (ClosedChannelException e) {
             // expected
         }
-
-        // throws ClosedChannelException first
-        writeBuffers[0] = null;
-        try {
-            readWriteFileChannel.write(writeBuffers, 0, 2);
-            fail("should throw ClosedChannelException");
-        } catch (ClosedChannelException e) {
-            // expected
-        }
     }
 
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NonWritableChannelException, " +
-                    "IndexOutOfBoundsException, NullPointerException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NonWritableChannelException, IndexOutOfBoundsException, NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_write$LByteBufferII_ReadOnly() throws Exception {
         ByteBuffer[] writeBuffers = new ByteBuffer[2];
         writeBuffers[0] = ByteBuffer.allocate(CAPACITY);
@@ -3268,7 +3544,7 @@ public class FileChannelTest extends TestCase {
         } catch (NonWritableChannelException e) {
             // expected
         }
-        
+
         readOnlyFileChannel.close();
         writeBuffers = null;
         try {
@@ -3277,7 +3553,7 @@ public class FileChannelTest extends TestCase {
         } catch (IndexOutOfBoundsException e) {
             // expected
         }
-        
+
         try {
             readOnlyFileChannel.write(writeBuffers, 0, 1);
             fail("should throw NullPointerException");
@@ -3289,17 +3565,141 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies NullPointerException.",
-              targets = {
-                @TestTarget(
-                  methodName = "write",
-                  methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void test_write$LByteBufferII_IndexOutOfBound() throws Exception {
+        ByteBuffer[] writeBuffers = new ByteBuffer[2];
+        writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
+        writeBuffers[1] = ByteBuffer.allocate(this.CONTENT_LENGTH);
+
+        try {
+            writeOnlyFileChannel.write(writeBuffers, -1, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            writeOnlyFileChannel.write(writeBuffers, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+
+        try {
+            readWriteFileChannel.write(writeBuffers, -1, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.write(writeBuffers, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.write(writeBuffers, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.write(writeBuffers, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.write(writeBuffers, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readWriteFileChannel.write(writeBuffers, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+
+        try {
+            readOnlyFileChannel.write(writeBuffers, -1, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.write(writeBuffers, 0, -1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.write(writeBuffers, 0, 3);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.write(writeBuffers, 1, 2);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.write(writeBuffers, 2, 1);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+        try {
+            readOnlyFileChannel.write(writeBuffers, 3, 0);
+            fail("should throw IndexOutOfBoundsException");
+        } catch (IndexOutOfBoundsException e) {
+            // expected
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_write$LByteBufferII_EmptyBuffers() throws Exception {
         ByteBuffer[] writeBuffers = new ByteBuffer[2];
+        writeBuffers[0] = ByteBuffer.allocate(this.CONTENT_LENGTH);
         try {
             writeOnlyFileChannel.write(writeBuffers, 0, 2);
             fail("should throw NullPointerException");
@@ -3318,15 +3718,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_write$LByteBufferII() throws Exception {
         ByteBuffer[] writeBuffers = new ByteBuffer[2];
         writeBuffers[0] = ByteBuffer.wrap(CONTENT_AS_BYTES);
@@ -3351,19 +3748,16 @@ public class FileChannelTest extends TestCase {
                 CONTENT_AS_BYTES_LENGTH, CONTENT_AS_BYTES_LENGTH);
         assertTrue(Arrays.equals(CONTENT_AS_BYTES, inputBuffer));
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "transferFrom",
-          methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_Closed()
             throws Exception {
         readByteChannel = DatagramChannel.open();
@@ -3403,15 +3797,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_SourceClosed()
             throws Exception {
         readByteChannel = DatagramChannel.open();
@@ -3450,15 +3841,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Verifies IllegalArgumentException.",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_IllegalArgument()
             throws Exception {
         readByteChannel = DatagramChannel.open();
@@ -3470,7 +3858,7 @@ public class FileChannelTest extends TestCase {
         }
 
         try {
-            readWriteFileChannel.transferFrom(readByteChannel, -1, -10);
+            readWriteFileChannel.transferFrom(readByteChannel, -1, 10);
             fail("should throw IllegalArgumentException.");
         } catch (IllegalArgumentException e) {
             // expected
@@ -3480,15 +3868,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_NonWritable()
             throws Exception {
         readByteChannel = DatagramChannel.open();
@@ -3503,15 +3888,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_SourceNonReadable()
             throws Exception {
         try {
@@ -3529,15 +3911,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_PositionBeyondSize()
             throws Exception {
         // init data to file.
@@ -3560,15 +3939,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_FileChannel()
             throws Exception {
         // init data to file.
@@ -3602,19 +3978,16 @@ public class FileChannelTest extends TestCase {
                 expectedContent, POSITION, LENGTH);
         assertTrue(Arrays.equals(expectedContent, resultContent));
     }
-    
+
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_DatagramChannel()
             throws Exception {
         // connects two datagramChannels.
@@ -3656,15 +4029,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_SocketChannel()
             throws Exception {
         // connects two socketChannels.
@@ -3704,15 +4074,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferFrom(ReadableByteChannel,long,long)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferFrom",
-                  methodArgs = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferFrom",
+        args = {java.nio.channels.ReadableByteChannel.class, long.class, long.class}
+    )
     public void test_transferFromLReadableByteChannelJJ_Pipe() throws Exception {
         // inits data in file.
         writeDataToFile(fileOfWriteOnlyFileChannel);
@@ -3748,15 +4115,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_Null() throws Exception {
         writableByteChannel = null;
         try {
@@ -3793,15 +4157,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "transferTo",
-          methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_Closed() throws Exception {
         writableByteChannel = DatagramChannel.open();
         readOnlyFileChannel.close();
@@ -3840,15 +4201,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_SourceClosed()
             throws Exception {
         writableByteChannel = DatagramChannel.open();
@@ -3887,15 +4245,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_IllegalArgument()
             throws Exception {
         writableByteChannel = DatagramChannel.open();
@@ -3907,7 +4262,7 @@ public class FileChannelTest extends TestCase {
         }
 
         try {
-            readWriteFileChannel.transferTo(-1, -10, writableByteChannel);
+            readWriteFileChannel.transferTo(-1, 10, writableByteChannel);
             fail("should throw IllegalArgumentException.");
         } catch (IllegalArgumentException e) {
             // expected
@@ -3917,15 +4272,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_NonReadable()
             throws Exception {
         writableByteChannel = DatagramChannel.open();
@@ -3940,15 +4292,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_TargetNonWritable()
             throws Exception {
         try {
@@ -3966,7 +4315,7 @@ public class FileChannelTest extends TestCase {
         } catch (NonWritableChannelException e) {
             // expected
         }
-        
+
         // regression test for Harmony-941
         // first throws NonWritableChannelException even arguments are illegal.
         try {
@@ -3987,15 +4336,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_PositionBeyondSize()
             throws Exception {
         // init data to file.
@@ -4018,15 +4364,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_FileChannel()
             throws Exception {
         // init data to file.
@@ -4065,15 +4408,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_SocketChannel()
             throws Exception {
         // inits data into file.
@@ -4132,15 +4472,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_DatagramChannel()
             throws Exception {
         // inits data to file.
@@ -4190,15 +4527,12 @@ public class FileChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.FileChannel#transferTo(long,long,WritableByteChannel)
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "transferTo",
-                  methodArgs = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "transferTo",
+        args = {long.class, long.class, java.nio.channels.WritableByteChannel.class}
+    )
     public void test_transferToJJLWritableByteChannel_Pipe() throws Exception {
         // inits data in file.
         writeDataToFile(fileOfReadOnlyFileChannel);
@@ -4226,15 +4560,15 @@ public class FileChannelTest extends TestCase {
             assertEquals(CONTENT_AS_BYTES[i], readBuffer.get());
         }
     }
-    
+
     private class MockFileChannel extends FileChannel {
-        
+
         private boolean isLockCalled = false;
-        
+
         private boolean isTryLockCalled = false;
-        
+
         private boolean isReadCalled = false;
-        
+
         private boolean isWriteCalled = false;
 
         public void force(boolean arg0) throws IOException {
@@ -4243,7 +4577,7 @@ public class FileChannelTest extends TestCase {
 
         public FileLock lock(long position, long size, boolean shared)
                 throws IOException {
-            // verify that calling lock() leads to the method 
+            // verify that calling lock() leads to the method
             // lock(0, Long.MAX_VALUE, false).
             if (0 == position && Long.MAX_VALUE == size && false == shared) {
                 isLockCalled = true;
@@ -4302,7 +4636,7 @@ public class FileChannelTest extends TestCase {
 
         public FileLock tryLock(long position, long size, boolean shared)
                 throws IOException {
-            // verify that calling tryLock() leads to the method 
+            // verify that calling tryLock() leads to the method
             // tryLock(0, Long.MAX_VALUE, false).
             if (0 == position && Long.MAX_VALUE == size && false == shared) {
                 isTryLockCalled = true;
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockInterruptionExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockInterruptionExceptionTest.java
index bc537cf..f1ccc96 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockInterruptionExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockInterruptionExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class FileLockInterruptionExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "FileLockInterruptionException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new FileLockInterruptionException());
@@ -52,15 +57,20 @@ public class FileLockInterruptionExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "FileLockInterruptionException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this,
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockTest.java
index 5bee734..6dc127e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/FileLockTest.java
@@ -16,8 +16,7 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -71,15 +70,12 @@ public class FileLockTest extends TestCase {
      * @tests java.nio.channels.FileLock#FileLock(FileChannel, long, long,
      *        boolean)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "FileLock",
-          methodArgs = {java.nio.channels.FileChannel.class, long.class, long.class, boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "FileLock",
+        args = {java.nio.channels.FileChannel.class, long.class, long.class, boolean.class}
+    )
     public void test_Constructor_Ljava_nio_channels_FileChannelJJZ() {
         FileLock fileLock1 = new MockFileLock(null, 0, 0, false);
         assertNull(fileLock1.channel());
@@ -108,15 +104,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#channel()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "channel",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "channel",
+        args = {}
+    )
     public void test_channel() {
         assertSame(readWriteChannel, mockLock.channel());
         FileLock lock = new MockFileLock(null, 0, 10, true);
@@ -126,15 +119,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#position()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "position",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "position",
+        args = {}
+    )
     public void test_position() {
         FileLock fileLock1 = new MockFileLock(readWriteChannel, 20, 100, true);
         assertEquals(20, fileLock1.position());
@@ -148,15 +138,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#size()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "size",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "size",
+        args = {}
+    )
     public void test_size() {
         FileLock fileLock1 = new MockFileLock(readWriteChannel, 20, 100, true);
         assertEquals(100, fileLock1.size());
@@ -171,15 +158,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#isShared()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "[check with false shared parameter]",
-      targets = {
-        @TestTarget(
-          methodName = "isShared",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "[check with false shared parameter]",
+        method = "isShared",
+        args = {}
+    )
     public void test_isShared() {
         assertFalse(mockLock.isShared());
         FileLock lock = new MockFileLock(null, 0, 10, true);
@@ -189,15 +173,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#overlaps(long, long)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "overlaps",
-          methodArgs = {long.class, long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "overlaps",
+        args = {long.class, long.class}
+    )
     public void test_overlaps_JJ() {
         assertTrue(mockLock.overlaps(0, 11));
         assertFalse(mockLock.overlaps(0, 10));
@@ -212,15 +193,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#isValid()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isValid",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )
     public void test_isValid() throws IOException {
         FileLock fileLock = readWriteChannel.lock();
         assertTrue(fileLock.isValid());
@@ -231,15 +209,12 @@ public class FileLockTest extends TestCase {
     /**
      * @tests java.nio.channels.FileLock#release()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "release",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "release",
+        args = {}
+    )
     public void test_release() throws Exception {
         File file = File.createTempFile("test", "tmp");
         file.deleteOnExit();
@@ -267,4 +242,22 @@ public class FileLockTest extends TestCase {
             //expected
         }
     }
+    
+    /**
+     * @tests java.nio.channels.FileLock#release()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
+    public void test_toString() throws Exception {
+        File file = File.createTempFile("test", "tmp");
+        file.deleteOnExit();
+        FileOutputStream fout = new FileOutputStream(file);
+        FileChannel fileChannel = fout.getChannel();
+        FileLock fileLock = fileChannel.lock();
+        assertTrue(fileLock.toString().length() > 0);
+    }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalBlockingModeExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalBlockingModeExceptionTest.java
index af9db67..4b1a840 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalBlockingModeExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalBlockingModeExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class IllegalBlockingModeExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "IllegalBlockingModeException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new IllegalBlockingModeException());
@@ -52,15 +57,20 @@ public class IllegalBlockingModeExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "IllegalBlockingModeException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalSelectorExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalSelectorExceptionTest.java
index 070aeb6..e8efc31 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalSelectorExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/IllegalSelectorExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class IllegalSelectorExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "IllegalSelectorException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new IllegalSelectorException());
@@ -52,15 +57,20 @@ public class IllegalSelectorExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "IllegalSelectorException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new IllegalSelectorException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MapModeTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MapModeTest.java
index 7a6699f..87835e3 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MapModeTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MapModeTest.java
@@ -16,8 +16,7 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -34,15 +33,12 @@ public class MapModeTest extends TestCase {
     /**
      * java.nio.channels.FileChannel.MapMode#PRIVATE,READONLY,READWRITE
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies fields.",
-              targets = {
-                @TestTarget(
-                  methodName = "!Constants",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies fields.",
+        method = "!Constants",
+        args = {}
+    )    
     public void test_PRIVATE_READONLY_READWRITE() {
         assertNotNull(FileChannel.MapMode.PRIVATE);
         assertNotNull(FileChannel.MapMode.READ_ONLY);
@@ -59,15 +55,12 @@ public class MapModeTest extends TestCase {
     /**
      * java.nio.channels.FileChannel.MapMode#toString()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "toString",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "toString",
+        args = {}
+    )
     public void test_toString() {
         assertNotNull(FileChannel.MapMode.PRIVATE.toString());
         assertNotNull(FileChannel.MapMode.READ_ONLY.toString());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MockSecurityManager.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MockSecurityManager.java
new file mode 100644
index 0000000..916140f
--- /dev/null
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/MockSecurityManager.java
@@ -0,0 +1,69 @@
+package org.apache.harmony.nio.tests.java.nio.channels;
+
+import java.security.Permission;
+
+class MockSecurityManager extends SecurityManager {
+
+    String validHost = null;
+
+    int validPort = -1;
+
+    public boolean checkAcceptCalled = false;
+    public boolean checkConnectCalled = false;
+
+    MockSecurityManager() {
+        super();
+        this.validHost = null;
+    }
+
+    MockSecurityManager(String host) {
+        super();
+        this.validHost = host;
+    }
+
+    MockSecurityManager(int port) {
+        super();
+        this.validPort = port;
+    }
+
+    public void checkPermission(Permission perm) {
+        // no-op
+    }
+
+    public void checkPermission(Permission perm, Object context) {
+        // no-op
+    }
+
+    public void checkConnect(String host, int port) {
+        checkConnectCalled = true;
+        // our local addr is OK.
+        if (null != this.validHost) {
+            if (!this.validHost.equals(host)) {
+                throw new SecurityException();
+            }
+        }
+        if ("127.0.0.1".equals(host)) {
+            return;
+        }
+        super.checkConnect(host, port);
+    }
+
+    public void checkAccept(String host, int port) {
+        checkAcceptCalled = true;
+        // our local addr is OK.
+        if (null != this.validHost) {
+            if (!this.validHost.equals(host)) {
+                throw new SecurityException();
+            }
+        }
+        if (-1 != this.validPort) {
+            if (this.validPort != port) {
+                throw new SecurityException();
+            }
+        }
+        if ("127.0.0.1".equals(host)) {
+            return;
+        }
+        super.checkAccept(host, port);
+    }
+}
\ No newline at end of file
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NoConnectionPendingExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NoConnectionPendingExceptionTest.java
index d78c466..8efe2ae 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NoConnectionPendingExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NoConnectionPendingExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class NoConnectionPendingExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NoConnectionPendingException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new NoConnectionPendingException());
@@ -52,15 +57,20 @@ public class NoConnectionPendingExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NoConnectionPendingException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonReadableChannelExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonReadableChannelExceptionTest.java
index ac6f820..d255e4b 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonReadableChannelExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonReadableChannelExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class NonReadableChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NonReadableChannelException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new NonReadableChannelException());
@@ -52,15 +57,20 @@ public class NonReadableChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NonReadableChannelException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new NonReadableChannelException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonWritableChannelExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonWritableChannelExceptionTest.java
index 9f767b9..fc23223 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonWritableChannelExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NonWritableChannelExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class NonWritableChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NonWritableChannelException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new NonWritableChannelException());
@@ -52,15 +57,20 @@ public class NonWritableChannelExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NonWritableChannelException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new NonWritableChannelException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetBoundExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetBoundExceptionTest.java
index 95f209b..d76d84a 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetBoundExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetBoundExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class NotYetBoundExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NotYetBoundException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new NotYetBoundException());
@@ -52,15 +57,20 @@ public class NotYetBoundExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NotYetBoundException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new NotYetBoundException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetConnectedExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetConnectedExceptionTest.java
index be27cc7..e1a8945 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetConnectedExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/NotYetConnectedExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class NotYetConnectedExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NotYetConnectedException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new NotYetConnectedException());
@@ -52,15 +57,20 @@ public class NotYetConnectedExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "NotYetConnectedException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new NotYetConnectedException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/OverlappingFileLockExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/OverlappingFileLockExceptionTest.java
index 5412b43..0c1cc8b 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/OverlappingFileLockExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/OverlappingFileLockExceptionTest.java
@@ -15,8 +15,8 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -35,15 +35,20 @@ public class OverlappingFileLockExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "OverlappingFileLockException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new OverlappingFileLockException());
@@ -52,15 +57,20 @@ public class OverlappingFileLockExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "OverlappingFileLockException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/PipeTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/PipeTest.java
index fb02750..5eb4f8b 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/PipeTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/PipeTest.java
@@ -16,8 +16,7 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -27,7 +26,16 @@ import java.nio.channels.Pipe.SinkChannel;
 import java.nio.channels.Pipe.SourceChannel;
 
 import junit.framework.TestCase;
-@TestTargetClass(Pipe.class)
+@TestTargetClass(
+    value = Pipe.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            method = "Pipe",
+            args = {}
+        )
+    }
+)
 /*
  * Tests for Pipe and its default implementation
  */
@@ -36,15 +44,12 @@ public class PipeTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe#open()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "open",
+        args = {}
+    )
     public void test_open() throws IOException{
         Pipe pipe = Pipe.open();
         assertNotNull(pipe);
@@ -53,15 +58,12 @@ public class PipeTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe#sink()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "sink",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "sink",
+        args = {}
+    )
     public void test_sink() throws IOException {
         Pipe pipe = Pipe.open();
         SinkChannel sink = pipe.sink();
@@ -71,19 +73,15 @@ public class PipeTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe#source()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "source",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "source",
+        args = {}
+    )
     public void test_source() throws IOException {
         Pipe pipe = Pipe.open();
         SourceChannel source = pipe.source();
         assertTrue(source.isBlocking());
     }
-
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectableChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectableChannelTest.java
index 23478ff..085e726 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectableChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectableChannelTest.java
@@ -16,8 +16,7 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -32,21 +31,28 @@ import junit.framework.TestCase;
 /*
  * Tests for SelectableChannel
  */
-@TestTargetClass(SelectableChannel.class)
+@TestTargetClass(
+    value = SelectableChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "SelectableChannel",
+            args = {}
+        )
+    }
+)
 public class SelectableChannelTest extends TestCase {
 
     /**
      * @tests SelectableChannel#register(Selector, int)
      */
-    @TestInfo(
-          level = TestLevel.COMPLETE,
-          purpose = "Abstract method.",
-          targets = {
-            @TestTarget(
-              methodName = "register",
-              methodArgs = {java.nio.channels.Selector.class, int.class}
-            )
-        })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Abstract method.",
+        method = "register",
+        args = {java.nio.channels.Selector.class, int.class}
+    )
     public void test_register_LSelectorI() throws IOException {
         MockSelectableChannel msc = new MockSelectableChannel();
         // Verify that calling register(Selector, int) leads to the method
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectionKeyTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectionKeyTest.java
index 68b6532..06e1a69 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectionKeyTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectionKeyTest.java
@@ -16,8 +16,7 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -25,10 +24,12 @@ import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.nio.channels.CancelledKeyException;
+import java.nio.channels.Pipe;
 import java.nio.channels.SelectableChannel;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.SocketChannel;
+import java.nio.channels.spi.SelectorProvider;
 
 import junit.framework.TestCase;
 import tests.support.Support_PortManager;
@@ -36,7 +37,17 @@ import tests.support.Support_PortManager;
 /*
  * Tests for SelectionKey and its default implementation
  */
-@TestTargetClass(SelectionKey.class)
+@TestTargetClass(
+    value = SelectionKey.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "SelectionKey",
+            args = {}
+        )
+    }
+)
 public class SelectionKeyTest extends TestCase {
 
     Selector selector;
@@ -102,15 +113,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#attach(Object)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "attach",
-          methodArgs = {Object.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "attach",
+        args = {java.lang.Object.class}
+    )
     public void test_attach() {
         MockSelectionKey mockSelectionKey = new MockSelectionKey(SelectionKey.OP_ACCEPT);
         // no previous, return null
@@ -129,15 +137,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#attachment()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "attachment",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "attachment",
+        args = {}
+    )
     public void test_attachment() {
         MockSelectionKey mockSelectionKey = new MockSelectionKey(SelectionKey.OP_ACCEPT);
         assertNull(mockSelectionKey.attachment());
@@ -149,15 +154,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#channel()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "channel",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "channel",
+        args = {}
+    )
     public void test_channel() {
         assertSame(sc, selectionKey.channel());
         // can be invoked even canceled
@@ -168,15 +170,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#interestOps()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "interestOps",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "interestOps",
+        args = {}
+    )
     public void test_interestOps() {
         assertEquals(SelectionKey.OP_CONNECT, selectionKey.interestOps());
     }
@@ -184,15 +183,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#interestOps(int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify CancelledKeyException.",
-      targets = {
-        @TestTarget(
-          methodName = "interestOps",
-          methodArgs = {int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Doesn't verify CancelledKeyException.",
+        method = "interestOps",
+        args = {int.class}
+    )
     public void test_interestOpsI() {
         selectionKey.interestOps(SelectionKey.OP_WRITE);
         assertEquals(SelectionKey.OP_WRITE, selectionKey.interestOps());
@@ -216,21 +212,25 @@ public class SelectionKeyTest extends TestCase {
         } catch (IllegalArgumentException ex) {
             // expected;
         }
-        
+
+        selectionKey.cancel();
+        try {
+            selectionKey.interestOps(-1);
+            fail("should throw IAE.");
+        } catch (CancelledKeyException ex) {
+            // expected;
+        }
     }
 
     /**
      * @tests java.nio.channels.SelectionKey#isValid()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isValid",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )
     public void test_isValid() {
         assertTrue(selectionKey.isValid());
     }
@@ -238,15 +238,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isValid()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "isValid",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )    
     public void test_isValid_KeyCancelled() {
         selectionKey.cancel();
         assertFalse(selectionKey.isValid());
@@ -255,15 +252,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isValid()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "isValid",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )    
     public void test_isValid_ChannelColsed() throws IOException {
         sc.close();
         assertFalse(selectionKey.isValid());
@@ -272,15 +266,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isValid()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL_OK,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "isValid",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )    
     public void test_isValid_SelectorClosed() throws IOException {
         selector.close();
         assertFalse(selectionKey.isValid());
@@ -289,15 +280,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isAcceptable()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isAcceptable",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isAcceptable",
+        args = {}
+    )
     public void test_isAcceptable() throws IOException {
         MockSelectionKey mockSelectionKey1 = new MockSelectionKey(SelectionKey.OP_ACCEPT);
         assertTrue(mockSelectionKey1.isAcceptable());
@@ -308,15 +296,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isConnectable()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isConnectable",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isConnectable",
+        args = {}
+    )
     public void test_isConnectable() {
         MockSelectionKey mockSelectionKey1 = new MockSelectionKey(SelectionKey.OP_CONNECT);
         assertTrue(mockSelectionKey1.isConnectable());
@@ -327,15 +312,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isReadable()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isReadable",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isReadable",
+        args = {}
+    )
     public void test_isReadable() {
         MockSelectionKey mockSelectionKey1 = new MockSelectionKey(SelectionKey.OP_READ);
         assertTrue(mockSelectionKey1.isReadable());
@@ -346,34 +328,43 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#isWritable()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify CancelledKeyException.",
-      targets = {
-        @TestTarget(
-          methodName = "isWritable",
-          methodArgs = {}
-        )
-    })
-    public void test_isWritable() {
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isWritable",
+        args = {}
+    )
+    public void test_isWritable() throws Exception {
         MockSelectionKey mockSelectionKey1 = new MockSelectionKey(SelectionKey.OP_WRITE);
         assertTrue(mockSelectionKey1.isWritable());
         MockSelectionKey mockSelectionKey2 = new MockSelectionKey(SelectionKey.OP_ACCEPT);
         assertFalse(mockSelectionKey2.isWritable());
+
+        Selector selector = SelectorProvider.provider().openSelector();
+        
+        Pipe pipe = SelectorProvider.provider().openPipe();
+        pipe.open();
+        pipe.sink().configureBlocking(false);
+        SelectionKey key = pipe.sink().register(selector, SelectionKey.OP_WRITE);
+        
+        key.cancel();
+        try {
+            key.isWritable();
+            fail("should throw IAE.");
+        } catch (CancelledKeyException ex) {
+            // expected;
+        }
     }
 
     /**
      * @tests java.nio.channels.SelectionKey#cancel()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "cancel",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "cancel",
+        args = {}
+    )
     public void test_cancel() {
         selectionKey.cancel();
         try {
@@ -426,15 +417,12 @@ public class SelectionKeyTest extends TestCase {
     /**
      * @tests java.nio.channels.SelectionKey#readyOps()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify CancelledKeyException.",
-      targets = {
-        @TestTarget(
-          methodName = "readyOps",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "readyOps",
+        args = {}
+    )
     public void test_readyOps() throws IOException {
         int port = Support_PortManager.getNextPort();
         ServerSocket ss = new ServerSocket(port);
@@ -448,21 +436,25 @@ public class SelectionKeyTest extends TestCase {
             ss.close();
             ss = null;
         }
-      
+
+        selectionKey.cancel();
+        try {
+            selectionKey.readyOps();
+            fail("should throw IAE.");
+        } catch (CancelledKeyException ex) {
+            // expected;
+        }
     }
 
     /**
      * @tests java.nio.channels.SelectionKey#selector()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "selector",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "selector",
+        args = {}
+    )
     public void test_selector() {
         assertSame(selector, selectionKey.selector());
         selectionKey.cancel();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectorTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectorTest.java
index feb1c92..883ca28 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectorTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SelectorTest.java
@@ -16,8 +16,8 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -40,7 +40,17 @@ import tests.support.Support_PortManager;
 /*
  * Tests for Selector and its default implementation
  */
-@TestTargetClass(Selector.class)
+@TestTargetClass(
+    value = Selector.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "Selector",
+            args = {}
+        )
+    }
+)
 public class SelectorTest extends TestCase {
 
     private static final int WAIT_TIME = 100;
@@ -56,7 +66,7 @@ public class SelectorTest extends TestCase {
 
     enum SelectType {
         NULL, TIMEOUT, NOW
-    };
+    }
 
     protected void setUp() throws Exception {
         super.setUp();
@@ -85,15 +95,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channels.Selector#open()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "open",
+        args = {}
+    )
     public void test_open() throws IOException {
         assertNotNull(selector);
     }
@@ -101,15 +108,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests Selector#isOpen()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isOpen",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isOpen",
+        args = {}
+    )
     public void test_isOpen() throws IOException {
         assertTrue(selector.isOpen());
         selector.close();
@@ -119,15 +123,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channels.Selector#provider()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "provider",
+        args = {}
+    )
     public void test_provider() throws IOException {
         // should be system default provider
         assertNotNull(selector.provider());
@@ -137,15 +138,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channels.Selector#keys()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "keys",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "keys",
+        args = {}
+    )
     public void test_keys() throws IOException {
         SelectionKey key = ssc.register(selector, SelectionKey.OP_ACCEPT);
         
@@ -192,15 +190,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channels.Selector#keys()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "selectedKeys",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "selectedKeys",
+        args = {}
+    )
     public void test_selectedKeys() throws IOException {
         SocketChannel sc = SocketChannel.open();
         ssc.register(selector, SelectionKey.OP_ACCEPT);
@@ -246,17 +241,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#selectNow()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies selectNow() method for Selector registered with " +
-           "SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, " +
-           "SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys.",
-      targets = {
-        @TestTarget(
-          methodName = "selectNow",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies selectNow() method for Selector registered with SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys.",
+        method = "selectNow",
+        args = {}
+    )
     public void test_selectNow() throws IOException {
         assert_select_OP_ACCEPT(SelectType.NOW, 0);
         assert_select_OP_CONNECT(SelectType.NOW, 0);
@@ -267,16 +257,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#selectNow()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that ClosedSelectorException is thrown " +
-            "if selectNow() method is called for closed Selector.",
-      targets = {
-        @TestTarget(
-          methodName = "selectNow",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that ClosedSelectorException is thrown if selectNow() method is called for closed Selector.",
+        method = "selectNow",
+        args = {}
+    )
     public void test_selectNow_SelectorClosed() throws IOException {
         assert_select_SelectorClosed(SelectType.NOW, 0);
     }
@@ -284,15 +270,12 @@ public class SelectorTest extends TestCase {
     /**
      * @test java.nio.channels.Selector#selectNow()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that selectNow() method doesn't block.",
-      targets = {
-        @TestTarget(
-          methodName = "selectNow",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that selectNow() method doesn't block.",
+        method = "selectNow",
+        args = {}
+    )
     public void test_selectNow_Timeout() throws IOException {
         // make sure selectNow doesn't block
         selector.selectNow();
@@ -301,17 +284,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#select()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies select() method for Selector registered with " +
-            "SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, " +
-            "SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies select() method for Selector registered with SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys.",
+        method = "select",
+        args = {}
+    )
     public void test_select() throws IOException {
         assert_select_OP_ACCEPT(SelectType.NULL, 0);
         assert_select_OP_CONNECT(SelectType.NULL, 0);
@@ -322,16 +300,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#select()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that ClosedSelectorException is thrown " +
-            "if select() method is called for closed Selector.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that ClosedSelectorException is thrown if select() method is called for closed Selector.",
+        method = "select",
+        args = {}
+    )
     public void test_select_SelectorClosed() throws IOException {
         assert_select_SelectorClosed(SelectType.NULL, 0);
     }
@@ -339,18 +313,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#select(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies select(long) method for Selector registered with " +
-           "SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, " +
-           "SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys and different " +
-           "timeout's values.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies select(long) method for Selector registered with SelectionKeys.OP_ACCEPT,  SelectionKeys.OP_CONNECT, SelectionKeys.OP_READ, SelectionKeys.OP_WRITE keys and different timeout's values.",
+        method = "select",
+        args = {long.class}
+    )
     public void test_selectJ() throws IOException {
         assert_select_OP_ACCEPT(SelectType.TIMEOUT, 0);
         assert_select_OP_CONNECT(SelectType.TIMEOUT, 0);
@@ -364,18 +332,38 @@ public class SelectorTest extends TestCase {
     }
 
     /**
+     * @test java.nio.channels.Selector#select(long)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies select(long) method for empty selection keys.",
+        method = "select",
+        args = {long.class}
+    )
+    @KnownFailure("fixed in ToT")
+    public void test_selectJ_Empty_Keys() throws IOException {
+        // regression test, see HARMONY-3888.
+        // make sure select(long) does wait for specified amount of
+        // time if keys.size() == 0 (initial state of selector).
+
+        final long SELECT_TIMEOUT = 1000;
+
+        long time1 = System.currentTimeMillis();
+        selector.select(SELECT_TIMEOUT);
+        long time2 = System.currentTimeMillis();
+        assertEquals("elapsed time", SELECT_TIMEOUT, (time2 - time1),
+                     SELECT_TIMEOUT * 0.05); // 5% accuracy
+    }
+
+    /**
      * @tests java.nio.channel.Selector#select(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that ClosedSelectorException is thrown " +
-            "if select(long) method is called for closed Selector.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that ClosedSelectorException is thrown if select(long) method is called for closed Selector.",
+        method = "select",
+        args = {long.class}
+    )
     public void test_selectJ_SelectorClosed() throws IOException {
         assert_select_SelectorClosed(SelectType.TIMEOUT, 0);
         selector = Selector.open();
@@ -385,15 +373,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channel.Selector#select(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalArgumentException.",
+        method = "select",
+        args = {long.class}
+    )
     public void test_selectJ_Exception() throws IOException {
         try {
             selector.select(-1);
@@ -405,15 +390,12 @@ public class SelectorTest extends TestCase {
     /**
      * @test java.nio.channels.Selector#select(long)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "Verifies that select(timeout) doesn't block.",
-      targets = {
-        @TestTarget(
-          methodName = "select",
-          methodArgs = {long.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that select(timeout) doesn't block.",
+        method = "select",
+        args = {long.class}
+    )
     public void test_selectJ_Timeout() throws IOException {
         // make sure select(timeout) doesn't block
         selector.select(WAIT_TIME);
@@ -422,15 +404,12 @@ public class SelectorTest extends TestCase {
     /**
      * @tests java.nio.channels.Selector#wakeup()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "wakeup",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "wakeup",
+        args = {}
+    )
     public void test_wakeup() throws IOException {
         /*
          * make sure the test does not block on select
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ServerSocketChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ServerSocketChannelTest.java
index 9c8ab91..988cef6 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ServerSocketChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/ServerSocketChannelTest.java
@@ -17,8 +17,9 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
 
@@ -30,6 +31,7 @@ import java.net.ServerSocket;
 import java.net.Socket;
 import java.nio.ByteBuffer;
 import java.nio.channels.AsynchronousCloseException;
+import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.NotYetBoundException;
@@ -39,6 +41,7 @@ import java.nio.channels.SocketChannel;
 import java.nio.channels.spi.SelectorProvider;
 
 import junit.framework.TestCase;
+
 import tests.support.Support_PortManager;
 
 /*
@@ -90,20 +93,32 @@ public class ServerSocketChannelTest extends TestCase {
     // -------------------------------------------------------------------
     // Test for methods in abstract class.
     // -------------------------------------------------------------------
+    /*
+     * Test method for 'java.nio.channels.ServerSocketChannel()'
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "ServerSocketChannel",
+        args = {java.nio.channels.spi.SelectorProvider.class}
+    )
+    public void testConstructor() throws IOException {
+        ServerSocketChannel channel = 
+                SelectorProvider.provider().openServerSocketChannel();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+    }
 
     /*
      * Test method for 'java.nio.channels.ServerSocketChannel.validOps()'
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "validOps",
-          methodArgs = {}
-        )
-    })
-    public void testValidOps() {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "validOps",
+        args = {}
+    )
+    public void test_validOps() {
         MockServerSocketChannel testMSChnlnull = new MockServerSocketChannel(
                 null);
         MockServerSocketChannel testMSChnl = new MockServerSocketChannel(
@@ -117,44 +132,57 @@ public class ServerSocketChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.ServerSocketChannel.open()'
      */
-    @TestInfo(
-      level = TestLevel.TODO,
-      purpose = "Doesn't call open() method.",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {}
-        )
-    })
-    public void testOpen() {
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies in setUp method.",
+        method = "open",
+        args = {}
+    )
+    public void test_open() {
         MockServerSocketChannel testMSChnl = new MockServerSocketChannel(null);
         MockServerSocketChannel testMSChnlnotnull = new MockServerSocketChannel(
                 SelectorProvider.provider());
         assertEquals(SelectionKey.OP_ACCEPT, testMSChnlnotnull.validOps());
         assertNull(testMSChnl.provider());
         assertNotNull(testMSChnlnotnull.provider());
-        assertNotNull(this.serverChannel.provider());
         assertEquals(testMSChnlnotnull.provider(), this.serverChannel
                 .provider());
     }
 
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isOpen",
+        args = {}
+    )
+    public void testIsOpen() throws Exception {
+        assertTrue(this.serverChannel.isOpen());
+        this.serverChannel.close();
+        assertFalse(this.serverChannel.isOpen());
+    }
+
     // -------------------------------------------------------------------
     // Test for socket()
     // -------------------------------------------------------------------
 
     /*
      * Test method for 'com.ibm.io.nio.ServerSocketChannelImpl.socket()'
+     * Test method for 'com.ibm.io.nio.ServerSocketChannelImpl.isOpen()'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "socket",
+            args = {}
+        ),@TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "isOpen",
+            args = {}
         )
     })
-    public void testSocket_Block_BeforeClose() throws Exception {
+    public void test_socket_Block_BeforeClose() throws Exception {
         assertTrue(this.serverChannel.isOpen());
         assertTrue(this.serverChannel.isBlocking());
         ServerSocket s1 = this.serverChannel.socket();
@@ -169,16 +197,14 @@ public class ServerSocketChannelTest extends TestCase {
         assertFalse(this.serverChannel.isOpen());
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
-    public void testSocket_NonBlock_BeforeClose() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
+    public void test_socket_NonBlock_BeforeClose() throws Exception {
         assertTrue(this.serverChannel.isOpen());
         this.serverChannel.configureBlocking(false);
         ServerSocket s1 = this.serverChannel.socket();
@@ -193,16 +219,14 @@ public class ServerSocketChannelTest extends TestCase {
         assertFalse(this.serverChannel.isOpen());
 
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
-    public void testSocket_Block_Closed() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
+    public void test_socket_Block_Closed() throws Exception {
         this.serverChannel.close();
         assertFalse(this.serverChannel.isOpen());
         assertTrue(this.serverChannel.isBlocking());
@@ -213,16 +237,14 @@ public class ServerSocketChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
-    public void testSocket_NonBlock_Closed() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
+    public void test_socket_NonBlock_Closed() throws Exception {
         this.serverChannel.configureBlocking(false);
         this.serverChannel.close();
         assertFalse(this.serverChannel.isBlocking());
@@ -242,25 +264,31 @@ public class ServerSocketChannelTest extends TestCase {
         assertNull(s.getLocalSocketAddress());
         assertEquals(0, s.getSoTimeout());
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies default status of ServerSocketChannel.",
-      targets = {
-        @TestTarget(
-          methodName = "validOps",
-          methodArgs = {}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of ServerSocketChannel.",
+            method = "validOps",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of ServerSocketChannel.",
+            method = "provider",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "isRegistered",
-          methodArgs = {}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of ServerSocketChannel.",
+            method = "isRegistered",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "isBlocking",
-          methodArgs = {}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of ServerSocketChannel.",
+            method = "isBlocking",
+            args = {}
         )
     })
     public void testChannelBasicStatus() {
@@ -279,16 +307,13 @@ public class ServerSocketChannelTest extends TestCase {
     /*
      * Test method for 'com.ibm.io.nio.ServerSocketChannelImpl.accept()'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NotYetBoundException.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void testAccept_Block_NotYetBound() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NotYetBoundException.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_Block_NotYetBound() throws IOException {
         assertTrue(this.serverChannel.isOpen());
         assertTrue(this.serverChannel.isBlocking());
         try {
@@ -298,16 +323,14 @@ public class ServerSocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies NotYetBoundException.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void testAccept_NonBlock_NotYetBound() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NotYetBoundException.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_NonBlock_NotYetBound() throws IOException {
         assertTrue(this.serverChannel.isOpen());
         this.serverChannel.configureBlocking(false);
         try {
@@ -317,16 +340,14 @@ public class ServerSocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void testAccept_ClosedChannel() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_ClosedChannel() throws Exception {
         this.serverChannel.close();
         assertFalse(this.serverChannel.isOpen());
         try {
@@ -336,16 +357,14 @@ public class ServerSocketChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies AsynchronousCloseException.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void testAccept_Block_NoConnect() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies AsynchronousCloseException.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_Block_NoConnect_close() throws IOException {
         assertTrue(this.serverChannel.isBlocking());
         ServerSocket gotSocket = this.serverChannel.socket();
         gotSocket.bind(localAddr1);         
@@ -369,17 +388,52 @@ public class ServerSocketChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that accept() returns null if the channel is in " +
-            "non-blocking mode and no connection is available to be accepted.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void testAccept_NonBlock_NoConnect() throws IOException {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedByInterruptException.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_Block_NoConnect_interrupt() throws IOException {
+        assertTrue(this.serverChannel.isBlocking());
+        ServerSocket gotSocket = this.serverChannel.socket();
+        gotSocket.bind(localAddr1);
+
+        class MyThread extends Thread {
+            public String errMsg = null;
+            public void run() {
+                try {
+                    serverChannel.accept();
+                    errMsg = "should throw ClosedByInterruptException";
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                } catch (Exception e) {
+                    errMsg = "caught wrong Exception: " + e.getClass() + ": " + 
+                            e.getMessage();
+                }
+            }
+        }
+        MyThread thread = new MyThread();
+        thread.start();
+        try {
+            Thread.currentThread().sleep(TIME_UNIT);
+            thread.interrupt();
+        } catch (InterruptedException e) {
+            fail("Should not throw a InterruptedException");
+        }
+        if (thread.errMsg != null) {
+            fail(thread.errMsg);
+        }
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that accept() returns null if the channel is in non-blocking mode and no connection is available to be accepted.",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_NonBlock_NoConnect() throws IOException {
         ServerSocket gotSocket = this.serverChannel.socket();
         gotSocket.bind(localAddr1); 
         this.serverChannel.configureBlocking(false);
@@ -390,16 +444,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void test_read_Blocking_RealData() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_socket_read_Block() throws IOException {
         serverChannel.socket().bind(localAddr1);
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
 
@@ -437,16 +488,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "accept",
-                  methodArgs = {}
-                )
-            })    
-    public void test_read_NonBlocking_RealData() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )    
+    public void test_accept_socket_read_NonBlock() throws Exception {
         serverChannel.configureBlocking(false);
         serverChannel.socket().bind(localAddr1);
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_NORMAL);
@@ -465,16 +513,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void test_write_Blocking_RealData() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_socket_write_Block() throws IOException {
         assertTrue(serverChannel.isBlocking());
         ServerSocket serverSocket = serverChannel.socket();
         serverSocket.bind(localAddr1);
@@ -496,16 +541,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void test_write_NonBlocking_RealData() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_socket_write_NonBlock() throws Exception {
         serverChannel.configureBlocking(false);
         ServerSocket serverSocket = serverChannel.socket();
         serverSocket.bind(localAddr1);
@@ -525,17 +567,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "accept",
-                  methodArgs = {}
-                )
-            })    
-    public void test_read_LByteBuffer_Blocking_ReadWriteRealLargeData()
-            throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )    
+    public void test_accept_socket_read_Block_RWLargeData() throws IOException {
         serverChannel.socket().bind(localAddr1);
         ByteBuffer buf = ByteBuffer.allocate(CAPACITY_64KB);
         for (int i = 0; i < CAPACITY_64KB; i++) {
@@ -553,16 +591,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "",
-              targets = {
-                @TestTarget(
-                  methodName = "accept",
-                  methodArgs = {}
-                )
-            })    
-    public void test_read_LByteBuffer_NonBlocking_ReadWriteRealLargeData()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )    
+    public void test_accept_socket_read_NonBlock_RWLargeData()
             throws Exception {
         serverChannel.configureBlocking(false);
         serverChannel.socket().bind(localAddr1);
@@ -582,16 +617,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void test_write_LByteBuffer_NonBlocking_ReadWriteRealLargeData()
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_socket_write_NonBlock_RWLargeData()
             throws Exception {
         serverChannel.configureBlocking(false);
         serverChannel.socket().bind(localAddr1);
@@ -610,17 +642,13 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#accept().socket()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
-    public void test_write_LByteBuffer_Blocking_ReadWriteRealLargeData()
-            throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_socket_write_Block_RWLargeData() throws Exception {
         serverChannel.socket().bind(localAddr1);
         byte[] writeContent = new byte[CAPACITY_64KB];
         for (int i = 0; i < writeContent.length; i++) {
@@ -659,48 +687,79 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocketChannel#socket().getSoTimeout()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies that accept method  returns null since " +
-            "there are no pending connections. Doesn't verify exceptions.",
-      targets = {
-        @TestTarget(
-          methodName = "accept",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that accept method  returns null since there are no pending connections. Doesn't verify exceptions.",
+        method = "accept",
+        args = {}
+    )
     public void test_accept_SOTIMEOUT() throws IOException {
         // regression test for Harmony-707        
         final int SO_TIMEOUT = 10;
-        ServerSocketChannel sc = ServerSocketChannel.open();
+        ServerSocketChannel ssc = ServerSocketChannel.open();
         try {
-            ServerSocket ss = sc.socket();
+            ServerSocket ss = ssc.socket();
             ss.bind(localAddr1);
-            sc.configureBlocking(false);
+            ssc.configureBlocking(false);
             ss.setSoTimeout(SO_TIMEOUT);
-            SocketChannel client = sc.accept();
+            SocketChannel client = ssc.accept();
             // non blocking mode, returns null since there are no pending connections.
             assertNull(client);
             int soTimeout = ss.getSoTimeout();
-            // Harmony fails here.
+            // Harmony failed here.
             assertEquals(SO_TIMEOUT, soTimeout);
         } finally {
-            sc.close();
+            ssc.close();
         }
     }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "accept",
+        args = {}
+    )
+    public void test_accept_Security() throws IOException {
+        this.clientChannel.configureBlocking(true);
+        this.serverChannel.configureBlocking(true);
+        SecurityManager sm = System.getSecurityManager();
+        MockSecurityManager mockManager = new MockSecurityManager("127.0.0.1");
+        System.setSecurityManager(mockManager);
+
+        Thread t = new Thread() {
+            public void run() {
+                try {
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                    }
+                    clientChannel.connect(localAddr1);
+                } catch (IOException e) {
+                }
+            }
+        };
+        t.start();
+
+        try {
+            ServerSocket ss = this.serverChannel.socket();
+            ss.bind(localAddr1);
+            this.serverChannel.accept();
+        } finally {
+            System.setSecurityManager(sm);
+        }
+
+        assertTrue(mockManager.checkAcceptCalled);
+    }
     
     /**
      * @tests ServerSocket#socket().accept()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Regression test. Verifies IllegalBlockingModeException.",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies IllegalBlockingModeException.",
+        method = "socket",
+        args = {}
+    )    
     public void test_socket_accept_Blocking_NotBound() throws IOException {
         // regression test for Harmony-748       
         ServerSocket gotSocket = serverChannel.socket();
@@ -723,15 +782,12 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocket#socket().accept()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Regression test. Verifies IllegalBlockingModeException.",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies IllegalBlockingModeException.",
+        method = "socket",
+        args = {}
+    )    
     public void test_socket_accept_Nonblocking_NotBound() throws IOException {
         // regression test for Harmony-748       
         ServerSocket gotSocket = serverChannel.socket();
@@ -754,16 +810,12 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocket#socket().accept()
      */
-    @TestInfo(
-              level = TestLevel.PARTIAL,
-              purpose = "Regression test. Verifies IllegalBlockingModeException, " +
-                    "ClosedChannelException.",
-              targets = {
-                @TestTarget(
-                  methodName = "socket",
-                  methodArgs = {}
-                )
-            })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies IllegalBlockingModeException, ClosedChannelException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_accept_Nonblocking_Bound() throws IOException {
         // regression test for Harmony-748
         serverChannel.configureBlocking(false);
@@ -787,15 +839,12 @@ public class ServerSocketChannelTest extends TestCase {
     /**
      * @tests ServerSocket#socket().accept()
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Regression test. Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies ClosedChannelException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_accept_Blocking_Bound() throws IOException {
         // regression test for Harmony-748
         serverChannel.configureBlocking(true);
@@ -809,4 +858,26 @@ public class ServerSocketChannelTest extends TestCase {
             // expected
         }
     }
+
+    /**
+     * Regression test for HARMONY-4961
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Regression test. Verifies that returned socket returns correct local port.",
+        method = "socket",
+        args = {}
+    )
+    @KnownFailure("Fixed in ToT")
+    public void test_socket_getLocalPort() throws IOException {
+        // regression test for Harmony-4961
+        serverChannel.socket().bind(localAddr1);
+        clientChannel.connect(localAddr1); 
+        SocketChannel myChannel = serverChannel.accept();
+        int port = myChannel.socket().getLocalPort();
+        assertEquals(localAddr1.getPort(), port);
+        myChannel.close();
+        clientChannel.close();
+        serverChannel.close();
+    }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SinkChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SinkChannelTest.java
index 5cf7dd0..849ef12 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SinkChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SinkChannelTest.java
@@ -16,26 +16,47 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestTarget;
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestLevel;
 import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargets;
 
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousCloseException;
+import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.Pipe;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
+import java.nio.channels.Pipe.SinkChannel;
+import java.nio.channels.spi.SelectorProvider;
 
 import junit.framework.TestCase;
-@TestTargetClass(java.nio.channels.Pipe.SinkChannel.class)
+
 /**
  * Tests for Pipe.SinkChannel class
  */
+@TestTargetClass(
+    value = java.nio.channels.Pipe.SinkChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "ClosedByInterruptException can not easily be tested",
+            method = "write",
+            args = {java.nio.ByteBuffer[].class}
+        ) 
+    }
+)
 public class SinkChannelTest extends TestCase {
 
     private static final int BUFFER_SIZE = 5;
@@ -65,15 +86,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#validOps()
      */
-    @TestInfo(
-            level = TestLevel.COMPLETE,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "validOps",                        
-                methodArgs = {}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "validOps",
+        args = {}
+    )
     public void test_validOps() {
         assertEquals(SelectionKey.OP_WRITE, sink.validOps());
     }
@@ -81,15 +99,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer [])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )    
     public void test_write_LByteBuffer() throws IOException {
         ByteBuffer[] bufArray = { buffer, positionedBuffer };
         boolean[] sinkBlockingMode = { true, true, false, false };
@@ -125,15 +140,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )    
     public void test_write_LByteBuffer_mutliThread() throws IOException,
             InterruptedException {
         final int THREAD_NUM = 20;
@@ -178,15 +190,66 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })    
+    public void disabled_test_read_LByteBuffer_mutliThread_close() throws Exception {
+
+        ByteBuffer sourceBuf = ByteBuffer.allocate(1000);
+        sink.configureBlocking(true);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.currentThread().sleep(500);
+                    sink.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            sink.write(sourceBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
+     */
+    public void disabled_test_read_LByteBuffer_mutliThread_interrupt() throws Exception {
+
+        sink.configureBlocking(true);
+
+        Thread thread = new Thread() {
+            public void run() {
+                try {
+                    sink.write(ByteBuffer.allocate(10));
+                    fail("should have thrown a ClosedByInterruptException.");
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                    return;
+                } catch (IOException e) {
+                    fail("should throw a ClosedByInterruptException but " +
+                            "threw " + e.getClass() + ": " + e.getMessage());
+                }
+            }
+        };
+        
+        thread.start();
+        Thread.currentThread().sleep(500);
+        thread.interrupt();
+        
+    }
+
+    /**
+     * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )    
     public void test_write_LByteBuffer_Exception() throws IOException {
         // write null ByteBuffer
         ByteBuffer nullBuf = null;
@@ -201,15 +264,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_write_LByteBuffer_SourceClosed() throws IOException {
         source.close();
         int written = sink.write(buffer);
@@ -219,16 +279,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies ClosedChannelException, " +
-                    "NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException, NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_write_LByteBuffer_SinkClosed() throws IOException {
         sink.close();
         try {
@@ -243,23 +299,22 @@ public class SinkChannelTest extends TestCase {
         try {
             sink.write(nullBuf);
             fail("should throw NullPointerException");
+        } catch (ClosedChannelException e) {
+            // expected on RI
         } catch (NullPointerException e) {
-            // expected
+            // expected on Harmony/Android
         }
     }
 
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void test_write_$LByteBuffer() throws IOException {
         ByteBuffer[] bufArray = { buffer, positionedBuffer };
         boolean[] sinkBlockingMode = { true, true, false, false };
@@ -293,15 +348,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void test_write_$LByteBuffer_Exception() throws IOException {
         // write null ByteBuffer[]
         ByteBuffer[] nullBufArrayRef = null;
@@ -326,15 +378,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void test_write_$LByteBuffer_SourceClosed() throws IOException {
         ByteBuffer[] bufArray = { buffer };
         source.close();
@@ -345,15 +394,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies ClosedChannelException, NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException, NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void test_write_$LByteBuffer_SinkClosed() throws IOException {
         ByteBuffer[] bufArray = { buffer };
         sink.close();
@@ -386,15 +432,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )    
     public void test_write_$LByteBufferII() throws IOException {
         ByteBuffer[] bufArray = { buffer, positionedBuffer };
         boolean[] sinkBlockingMode = { true, true, false, false };
@@ -424,16 +467,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException, " +
-                    "IndexOutOfBoundsException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })        
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, IndexOutOfBoundsException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )        
     public void test_write_$LByteBufferII_Exception() throws IOException {
         // write null ByteBuffer[]
         ByteBuffer[] nullBufArrayRef = null;
@@ -508,15 +547,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })        
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )        
     public void test_write_$LByteBufferII_SourceClosed() throws IOException {
         ByteBuffer[] bufArray = { buffer };
         source.close();
@@ -527,16 +563,12 @@ public class SinkChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#write(ByteBuffer[], int, int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies ClosedChannelException, NullPointerException, " +
-                    "IndexOutOfBoundsException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })        
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException, NullPointerException, IndexOutOfBoundsException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )        
     public void test_write_$LByteBufferII_SinkClosed() throws IOException {
         ByteBuffer[] bufArray = { buffer };
         sink.close();
@@ -620,35 +652,51 @@ public class SinkChannelTest extends TestCase {
 
     /**
      * @tests java.nio.channels.Pipe.SinkChannel#close()
+     * @tests {@link java.nio.channels.Pipe.SinkChannel#isOpen()}
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "Verifies write method after close.",
-      targets = {
-        @TestTarget(
-          methodName = "close",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
+        ),@TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "isOpen",
+            args = {}
         )
     })
     public void test_close() throws IOException {
+        assertTrue(sink.isOpen());
         sink.close();
         assertFalse(sink.isOpen());
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies that NullPointerException is thrown if " +
-                    "write method is called for closed channel.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer.class}
-              ),
-              @TestTarget(
-                methodName = "close",                        
-                methodArgs = {}
-              )              
-          })
-    public void test_socketChannel_read_close() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SinkChannel",
+        args = {java.nio.channels.spi.SelectorProvider.class}
+    )
+    public void testConstructor() throws IOException {
+        SinkChannel channel =
+                SelectorProvider.provider().openPipe().sink();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+        channel = Pipe.open().sink();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies that NullPointerException is thrown if write" +
+                "method is called for closed channel.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void test_socketChannel_closed() throws Exception {
         ServerSocketChannel ssc = ServerSocketChannel.open();
         ssc.socket().bind(new InetSocketAddress(InetAddress.getLocalHost(),49999));
         SocketChannel sc = SocketChannel.open();
@@ -671,16 +719,14 @@ public class SinkChannelTest extends TestCase {
         }
         sock.close();
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })
-    public void test_socketChannel_read_write() throws Exception {
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void test_socketChannel_empty() throws Exception {
         ServerSocketChannel ssc = ServerSocketChannel.open();
         ssc.socket().bind(new InetSocketAddress(InetAddress.getLocalHost(),49999));
         SocketChannel sc = SocketChannel.open();
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SocketChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SocketChannelTest.java
index f7c8822..d31cd0a 100755
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SocketChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SocketChannelTest.java
@@ -17,16 +17,19 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.KnownFailure;
+import dalvik.annotation.TestTargets;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 import dalvik.annotation.TestLevel;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.lang.annotation.Target;
 import java.net.BindException;
 import java.net.ConnectException;
+import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.ServerSocket;
 import java.net.Socket;
@@ -39,6 +42,9 @@ import java.nio.channels.ConnectionPendingException;
 import java.nio.channels.IllegalBlockingModeException;
 import java.nio.channels.NoConnectionPendingException;
 import java.nio.channels.NotYetConnectedException;
+import java.nio.channels.SelectableChannel;
+import java.nio.channels.SelectionKey;
+import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
 import java.nio.channels.SocketChannel;
 import java.nio.channels.UnresolvedAddressException;
@@ -56,6 +62,8 @@ public class SocketChannelTest extends TestCase {
 
     private static final int CAPACITY_NORMAL = 200;
 
+    private static final int CAPACITY_HUGE = 512 * 1024;
+
     private InetSocketAddress localAddr1;
 
     private InetSocketAddress localAddr2;
@@ -67,9 +75,9 @@ public class SocketChannelTest extends TestCase {
     private ServerSocket server1;
 
     private ServerSocket server2;
-    
+
     private final static int TIMEOUT = 60000;
-    
+
     private final static int EOF = -1;
 
     protected void setUp() throws Exception {
@@ -89,28 +97,28 @@ public class SocketChannelTest extends TestCase {
             try {
                 this.channel1.close();
             } catch (Exception e) {
-                //ignore
+                // ignore
             }
         }
         if (null != this.channel2) {
             try {
                 this.channel2.close();
             } catch (Exception e) {
-                //ignore
+                // ignore
             }
         }
         if (null != this.server1) {
             try {
                 this.server1.close();
             } catch (Exception e) {
-                //ignore
+                // ignore
             }
         }
         if (null != this.server2) {
             try {
                 this.server2.close();
             } catch (Exception e) {
-                //ignore
+                // ignore
             }
         }
     }
@@ -119,17 +127,57 @@ public class SocketChannelTest extends TestCase {
     // Test for methods in abstract class.
     // -------------------------------------------------------------------
     /*
-     * Test method for 'java.nio.channels.SocketChannel.validOps()'
+     * Test method for 'java.nio.channels.SocketChannel()'
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "validOps",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "SocketChannel",
+            args = {SelectorProvider.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "provider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "open",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            clazz = SelectorProvider.class,
+            method = "openSocketChannel",
+            args = {}
         )
     })
+    public void testConstructor() throws IOException {
+        SocketChannel channel = 
+                SelectorProvider.provider().openSocketChannel();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(), channel.provider());
+        channel = SocketChannel.open();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(), channel.provider());
+        MockSocketChannel chan = new MockSocketChannel(
+                SelectorProvider.provider());
+        assertTrue(chan.isConstructorCalled);
+    }
+
+    /*
+     * Test method for 'java.nio.channels.SocketChannel.validOps()'
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "validOps",
+        args = {}
+    )
     public void testValidOps() {
         MockSocketChannel testMSChannel = new MockSocketChannel(null);
         assertEquals(13, this.channel1.validOps());
@@ -139,13 +187,18 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.SocketChannel.open()'
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "open",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "SocketChannel",
+            args = {SelectorProvider.class}
         )
     })
     public void testOpen() throws IOException {
@@ -154,9 +207,12 @@ public class SocketChannelTest extends TestCase {
         MockSocketChannel testMSChannel = new MockSocketChannel(null);
         MockSocketChannel testMSChannelnotnull = new MockSocketChannel(
                 SelectorProvider.provider());
+        SocketChannel testSChannel = MockSocketChannel.open();
+        assertTrue(testSChannel.isOpen());
         assertNull(testMSChannel.provider());
+        assertNotNull(testSChannel.provider());
+        assertEquals(SelectorProvider.provider(), testSChannel.provider());
         assertNotNull(testMSChannelnotnull.provider());
-        assertNotNull(this.channel1);
         assertEquals(this.channel1.provider(), testMSChannelnotnull.provider());
         try {
             this.channel1.write(buf);
@@ -166,19 +222,139 @@ public class SocketChannelTest extends TestCase {
         }
     }
 
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isOpen",
+        args = {}
+    )
+    public void testIsOpen() throws Exception {
+        assertTrue(this.channel1.isOpen());
+        this.channel1.close();
+        assertFalse(this.channel1.isOpen());
+    }
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isConnected",
+        args = {}
+    )
+    public void testIsConnected() throws Exception {
+        assertFalse(this.channel1.isConnected());// not connected
+        this.channel1.configureBlocking(false);
+        assertFalse(this.channel1.connect(localAddr1));
+        assertFalse(this.channel1.isConnected());
+        assertTrue(this.channel1.isConnectionPending());
+        assertTrue(tryFinish());
+        assertTrue(this.channel1.isConnected());
+        this.channel1.close();
+        assertFalse(this.channel1.isConnected());
+    }
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isConnectionPending",
+        args = {}
+    )
+    public void testIsConnectionPending() throws Exception {
+        // ensure
+        ensureServerClosed();
+        this.channel1.configureBlocking(false);
+        assertFalse(this.channel1.isConnectionPending());
+        // finish
+        try {
+            this.channel1.finishConnect();
+            fail("Should throw NoConnectionPendingException");
+        } catch (NoConnectionPendingException e) {
+            // OK.
+        }
+        assertFalse(this.channel1.isConnectionPending());
+        // connect
+        assertFalse(this.channel1.connect(localAddr1));
+        assertTrue(this.channel1.isConnectionPending());
+        this.channel1.close();
+
+        assertFalse(this.channel1.isConnectionPending());
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of SocketChannel.",
+            method = "validOps",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of SocketChannel.",
+            method = "provider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of SocketChannel.",
+            method = "isRegistered",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies default status of SocketChannel.",
+            method = "isBlocking",
+            args = {}
+        )
+    })
+    public void testChannelBasicStatus() {
+        Socket gotSocket = this.channel1.socket();
+        assertFalse(gotSocket.isClosed());
+        assertTrue(this.channel1.isBlocking());
+        assertFalse(this.channel1.isRegistered());
+        assertEquals((SelectionKey.OP_CONNECT | SelectionKey.OP_READ |
+                SelectionKey.OP_WRITE), this.channel1.validOps());
+        assertEquals(SelectorProvider.provider(), this.channel1.provider());
+    }
+
     /*
      * Test method for 'java.nio.channels.SocketChannel.open(SocketAddress)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies IllegalArgumentException.",
-      targets = {
-        @TestTarget(
-          methodName = "open",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
-    public void testOpenSocketAddress_Null() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "open",
+        args = {java.net.SocketAddress.class}
+    )
+    public void testOpenSocketAddress() throws IOException {
+        this.channel1 = SocketChannel.open(localAddr1);
+        assertTrue(this.channel1.isConnected());
+        
+        SecurityManager smngr = System.getSecurityManager();
+        System.setSecurityManager(new MockSecurityManager("blargh"));
+        try {
+            this.channel1 = SocketChannel.open(localAddr2);
+            fail("Should throw SecurityException");
+        } catch (SecurityException e) {
+            // expected
+        }
+        System.setSecurityManager(smngr);
+
+        SocketAddress newTypeAddress = new SubSocketAddress();
+        try {
+            this.channel1 = SocketChannel.open(newTypeAddress);
+            fail("Should throw UnexpectedAddressTypeException");
+        } catch (UnsupportedAddressTypeException e) {
+            // expected
+        }
+
+        SocketAddress unresolvedAddress = 
+                InetSocketAddress.createUnresolved("127.0.0.1", 8080);
+        try {
+            this.channel1 = SocketChannel.open(unresolvedAddress);
+            fail("Should throw UnresolvedAddressException");
+        } catch (UnresolvedAddressException e) {
+            // expected
+        }
+        
         SocketChannel channel1IP = null;
         try {
             channel1IP = SocketChannel.open(null);
@@ -192,15 +368,12 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void testReadByteBufferArray() throws IOException {
         java.nio.ByteBuffer[] byteBuf = null;
         MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
@@ -236,15 +409,12 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.SocketChannel.read(ByteBuffer[])'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void testReadByteBufferArray_BufNull() throws IOException {
         java.nio.ByteBuffer[] byteBuf = null;
         MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
@@ -273,16 +443,13 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " +
-            "ClosedByInterruptException, ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify AsynchronousCloseException," +
+                "ClosedByInterruptException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void testWriteByteBufferArray() throws IOException {
         java.nio.ByteBuffer[] byteBuf = null;
         MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
@@ -294,7 +461,8 @@ public class SocketChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // correct
         }
-        byteBuf = new java.nio.ByteBuffer[CAPACITY_NORMAL];
+        byteBuf = new java.nio.ByteBuffer[1];
+        byteBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
         try {
             this.channel1.write(byteBuf);
             fail("Should throw NotYetConnectedException");
@@ -303,53 +471,52 @@ public class SocketChannelTest extends TestCase {
         }
         testMSChannel.write(byteBuf);
         testMSChannelnull.write(byteBuf);
+        
+        this.channel1.close();
+        try {
+            this.channel1.write(byteBuf);
+            fail("Should throw ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // correct
+        }
     }
 
     /*
      * Test method for 'java.nio.channels.SocketChannel.write(ByteBuffer[])'
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer[].class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
     public void testWriteByteBufferArray_BufNull() throws IOException {
         java.nio.ByteBuffer[] byteBuf = null;
         MockSocketChannel testMSChannelnull = new MockSocketChannel(null);
         MockSocketChannel testMSChannel = new MockSocketChannel(
                 SelectorProvider.provider());
+        this.channel1.connect(localAddr1);
         try {
             this.channel1.write(byteBuf);
             fail("Should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
+        byteBuf = new java.nio.ByteBuffer[1];
         try {
-            testMSChannel.write(byteBuf);
-            fail("Should throw NPE");
-        } catch (NullPointerException e) {
-            // correct
-        }
-        try {
-            testMSChannelnull.write(byteBuf);
+            this.channel1.write(byteBuf);
             fail("Should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL_OK,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "socket",
-          methodArgs = {}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_BasicStatusBeforeConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         Socket s1 = this.channel1.socket();
@@ -358,15 +525,13 @@ public class SocketChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_Block_BasicStatusAfterConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         assertTrue(this.channel1.connect(localAddr1));
@@ -379,15 +544,13 @@ public class SocketChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_NonBlock_BasicStatusAfterConnect() throws Exception {
         assertFalse(this.channel1.isConnected());// not connected
         this.channel1.configureBlocking(false);
@@ -401,38 +564,33 @@ public class SocketChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
 
-        if (tryFinish()) {
-            assertTrue(this.channel1.isConnected());
-            s1 = this.channel1.socket();
-            assertSocketAfterConnect(s1, localAddr1);
-            s2 = this.channel1.socket();
-            // same
-            assertSame(s1, s2);
-        }
-    }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+        assertTrue(tryFinish());
+        assertTrue(this.channel1.isConnected());
+        s1 = this.channel1.socket();
+        assertSocketAfterConnect(s1, localAddr1);
+        s2 = this.channel1.socket();
+        // same
+        assertSame(s1, s2);
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_Block_ActionsBeforeConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         Socket s = this.channel1.socket();
         assertSocketAction_Block_BeforeConnect(s);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_Block_ActionsAfterConnect() throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
         assertTrue(this.channel1.connect(localAddr1));
@@ -441,15 +599,13 @@ public class SocketChannelTest extends TestCase {
         assertSocketAction_Block_AfterConnect(s);
 
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_NonBlock_ActionsAfterConnectBeforeFinish()
             throws IOException {
         assertFalse(this.channel1.isConnected());// not connected
@@ -464,27 +620,24 @@ public class SocketChannelTest extends TestCase {
         // same
         assertSame(s1, s2);
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void testSocket_NonBlock_ActionsAfterConnectAfterFinish()
             throws Exception {
         assertFalse(this.channel1.isConnected());// not connected
         this.channel1.configureBlocking(false);
         assertFalse(this.channel1.connect(localAddr1));
-        if (tryFinish()) {
-            Socket s1 = this.channel1.socket();
-            assertSocketAction_NonBlock_AfterConnect(s1);
-            Socket s2 = this.channel1.socket();
-            // same
-            assertSame(s1, s2);
-        }
+        assertTrue(tryFinish());
+        Socket s1 = this.channel1.socket();
+        assertSocketAction_NonBlock_AfterConnect(s1);
+        Socket s2 = this.channel1.socket();
+        // same
+        assertSame(s1, s2);
     }
 
     private void assertSocketBeforeConnect(Socket s) throws IOException {
@@ -513,20 +666,20 @@ public class SocketChannelTest extends TestCase {
 
         assertNull(s.getInetAddress());
         assertEquals(s.getLocalAddress().getHostAddress(), "0.0.0.0");
-        // RI fails here. RI returns 0 while spec says unbound socket should
-        // return -1.
-        assertEquals(s.getLocalPort(), -1);
         assertFalse(s.getReuseAddress());
         assertNull(s.getLocalSocketAddress());
 
         // not connected
-        assertEquals(s.getPort(), 0);
+        assertEquals(0, s.getPort());
         assertTrue(s.getReceiveBufferSize() >= 8192);
         assertNull(s.getRemoteSocketAddress());
         assertTrue(s.getSendBufferSize() >= 8192);
-        assertEquals(s.getSoTimeout(), 0);
-        assertEquals(s.getTrafficClass(), 0);
+        assertEquals(0, s.getSoTimeout());
+        assertEquals(0, s.getTrafficClass());
 
+        // RI fails here. RI returns 0 while spec says unbound socket should
+        // return -1.
+        assertEquals(-1, s.getLocalPort());
     }
 
     private void assertSocketAfterConnect(Socket s, InetSocketAddress address)
@@ -548,17 +701,17 @@ public class SocketChannelTest extends TestCase {
 
         assertSame(s.getInetAddress(), address.getAddress());
 
-        assertEquals(s.getLocalAddress(), this.localAddr1.getAddress());
-        assertEquals(s.getPort(), address.getPort());
+        assertEquals(this.localAddr1.getAddress(), s.getLocalAddress());
+        assertEquals(address.getPort(), s.getPort());
         assertNotNull(s.getLocalSocketAddress());
         assertTrue(s.getReceiveBufferSize() >= 8192);
         // equal , not same
-        assertNotSame(s.getRemoteSocketAddress(), (SocketAddress) address);
-        assertEquals(s.getRemoteSocketAddress(), (SocketAddress) address);
+        assertNotSame(address, s.getRemoteSocketAddress());
+        assertEquals(address, s.getRemoteSocketAddress());
         // assertFalse(s.getReuseAddress());
         assertTrue(s.getSendBufferSize() >= 8192);
-        assertEquals(s.getSoTimeout(), 0);
-        assertEquals(s.getTrafficClass(), 0);
+        assertEquals(0, s.getSoTimeout());
+        assertEquals(0, s.getTrafficClass());
     }
 
     private void assertSocketAction_Block_BeforeConnect(Socket s)
@@ -620,7 +773,7 @@ public class SocketChannelTest extends TestCase {
 
     private void assertSocketAction_Block_AfterConnect(Socket s)
             throws IOException {
-        assertEquals(s.getPort(), localAddr1.getPort());
+        assertEquals(localAddr1.getPort(), s.getPort());
         assertTrue(this.channel1.isConnected());
         assertTrue(s.isConnected());
         try {
@@ -644,7 +797,7 @@ public class SocketChannelTest extends TestCase {
 
     private void assertSocketAction_NonBlock_AfterConnect(Socket s)
             throws IOException {
-        assertEquals(s.getPort(), localAddr1.getPort());
+        assertEquals(localAddr1.getPort(), s.getPort());
         assertTrue(this.channel1.isConnected());
         assertTrue(s.isConnected());
 
@@ -683,18 +836,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_Norml_NoServer_Block() throws Exception {
         // ensure
@@ -720,18 +874,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_Norml_NoServer_NonBlock() throws Exception {
         connectNoServerNonBlock();
@@ -743,18 +898,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_Norml_Server_Block() throws Exception {
         connectServerBlock();
@@ -767,18 +923,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_Norml_Server_NonBlock() throws Exception {
         connectServerNonBlock();
@@ -790,18 +947,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->server closed-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerClosed_Block() throws Exception {
         // ensure
@@ -824,18 +982,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->server closed-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerClosed_NonBlock() throws Exception {
         // ensure
@@ -857,18 +1016,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->server closed-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerClosedAfterFinish_Block() throws Exception {
         connectServerBlock();
@@ -883,18 +1043,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->server closed-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerClosedAfterFinish_NonBlock() throws Exception {
         connectServerNonBlock();
@@ -908,18 +1069,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * no server-->connect-->server open-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerStartLater_Block() throws Exception {
         // ensure
@@ -946,18 +1108,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * no server-->connect-->server open-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_ServerStartLater_NonBlock() throws Exception {
         // ensure
@@ -975,25 +1138,26 @@ public class SocketChannelTest extends TestCase {
             statusNotConnected_Pending();
             this.channel1.close();
         } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
+            // OK
         }
     }
 
     /**
      * connect-->finish-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_FinishTwice_NoServer_NonBlock() throws Exception {
         // ensure
@@ -1005,31 +1169,37 @@ public class SocketChannelTest extends TestCase {
         statusNotConnected_Pending();
         try {
             assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-            assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-            this.channel1.close();
         } catch (ConnectException e) {
-          // FIXME: assertEquals(e.getMessage(), "Connection refused");
+            // OK
+        }
+        statusChannelClosed();
+        try {
+            assertFalse(this.channel1.finishConnect());
+        } catch (ClosedChannelException e) {
+            // OK
         }
         statusChannelClosed();
+        
+        this.channel1.close();
+        statusChannelClosed();
     }
 
     /**
      * connect-->finish-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_FinishTwice_Server_Block() throws Exception {
         connectServerBlock();
@@ -1042,18 +1212,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_FinishTwice_Server_NonBlock() throws Exception {
         connectServerNonBlock();
@@ -1065,24 +1236,20 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->connect-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies case:  connect-->finish-->connect-->close. " +
-                    "Verifies ClosedChannelException, ConnectException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              ),
-              @TestTarget(
-                methodName = "configureBlocking",
-                methodArgs = {boolean.class}
-              )
-          })   
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case:  connect-->finish-->connect-->close. Verifies ClosedChannelException, ConnectException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case:  connect-->finish-->connect-->close. Verifies ClosedChannelException, ConnectException.",
+            method = "finishConnect",
+            args = {}
+        )
+    })   
     public void testCFII_ConnectAfterFinish_NoServer_Block() throws Exception {
         // ensure
         ensureServerClosed();
@@ -1115,20 +1282,20 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->connect-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies case: connect-->finish-->connect-->close. " +
-                    "Verifies ConnectionPendingException, ConnectException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
-          })    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case: connect-->finish-->connect-->close. Verifies ConnectionPendingException, ConnectException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case: connect-->finish-->connect-->close. Verifies ConnectionPendingException, ConnectException.",
+            method = "finishConnect",
+            args = {}
+        )
+    })    
     public void testCFII_ConnectAfterFinish_NoServer_NonBlock()
             throws Exception {
         // ensure
@@ -1138,67 +1305,55 @@ public class SocketChannelTest extends TestCase {
         // connect
         assertFalse(this.channel1.connect(localAddr1));
         statusNotConnected_Pending();
+
         try {
-            assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-        } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
+            this.channel1.connect(localAddr1);
+            fail("Should throw a ConnectionPendingException here.");
+        } catch (ConnectionPendingException e) {
+            // OK.
         }
+        statusNotConnected_Pending();
 
-        if (this.channel1.isOpen()) {
-
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw a ConnectionPendingException here.");
-            } catch (ConnectionPendingException e) {
-                // OK.
-            }
-            statusNotConnected_Pending();
+        // connect another addr
+        try {
+            this.channel1.connect(localAddr2);
+            fail("Should throw a ConnectionPendingException here.");
+        } catch (ConnectionPendingException e) {
+            // OK.
+        }
+        statusNotConnected_Pending();
 
-            // connect another addr
-            try {
-                this.channel1.connect(localAddr2);
-                fail("Should throw a ConnectionPendingException here.");
-            } catch (ConnectionPendingException e) {
-                // OK.
-            }
-            statusNotConnected_Pending();
+        // connect if server closed
+        ensureServerClosed();
 
-            // connect if server closed
-            ensureServerClosed();
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw a ConnectionPendingException here.");
+        } catch (ConnectionPendingException e) {
+            // OK.
+        }
+        statusNotConnected_Pending();
 
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw a ConnectionPendingException here.");
-            } catch (ConnectionPendingException e) {
-                // OK.
-            }
-            statusNotConnected_Pending();
+        this.channel1.close();
 
-            this.channel1.close();
-        }
         statusChannelClosed();
     }
 
     /**
      * connect-->finish-->connect-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies AlreadyConnectedException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              )
-          })        
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies AlreadyConnectedException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )        
     public void testCFII_ConnectAfterFinish_Server_Block() throws Exception {
         connectServerBlock();
 
         if (!this.channel1.isConnected()) {
-            System.err
-                    .println("Connection fail, testCFII_ConnectAfterFinish_Server_Block is not finished.");
-            return;
+            fail("Connection failed," +
+                    "testCFII_ConnectAfterFinish_Server_Block not finished.");
         }
 
         try {
@@ -1237,22 +1392,18 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->finish-->connect-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies AlreadyConnectedException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              )
-          })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies AlreadyConnectedException.",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )    
     public void testCFII_ConnectAfterFinish_Server_NonBlock() throws Exception {
         connectServerNonBlock();
 
         if (!this.channel1.isConnected()) {
-            System.err
-                    .println("Connection fail, testCFII_ConnectAfterFinish_Server_Block is not finished.");
-            return;
+            fail("Connection failed," +
+                    "testCFII_ConnectAfterFinish_Server_Block not finished.");
         }
         try {
             this.channel1.connect(localAddr1);
@@ -1290,20 +1441,20 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies case: connect-->connect-->finish-->close. " +
-                    "Verifies ConnectionPendingException, ConnectException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
-          }) 
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case: connect-->connect-->finish-->close. Verifies ConnectionPendingException, ConnectException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case: connect-->connect-->finish-->close. Verifies ConnectionPendingException, ConnectException.",
+            method = "finishConnect",
+            args = {}
+        )
+    }) 
     public void testCFII_ConnectTwice_NoServer_NonBlock() throws Exception {
         // ensure
         ensureServerClosed();
@@ -1340,14 +1491,7 @@ public class SocketChannelTest extends TestCase {
             // OK.
         }
         statusNotConnected_Pending();
-
-        try {
-            assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-            this.channel1.close();
-        } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
-        }
+        this.channel1.close();
 
         statusChannelClosed();
     }
@@ -1355,20 +1499,20 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies case connect-->connect-->finish-->close. " +
-                    "Verifies AlreadyConnectedException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
-          }) 
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case connect-->connect-->finish-->close. Verifies AlreadyConnectedException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case connect-->connect-->finish-->close. Verifies AlreadyConnectedException.",
+            method = "finishConnect",
+            args = {}
+        )
+    }) 
     public void testCFII_ConnectTwice_Server_Block() throws Exception {
         // ensure
         ensureServerOpen();
@@ -1416,20 +1560,20 @@ public class SocketChannelTest extends TestCase {
     /**
      * connect-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies case connect-->connect-->finish-->close. " +
-                    "Verifies ConnectionPendingException.",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
-          }) 
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case connect-->connect-->finish-->close. Verifies ConnectionPendingException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies case connect-->connect-->finish-->close. Verifies ConnectionPendingException.",
+            method = "finishConnect",
+            args = {}
+        )
+    }) 
     public void testCFII_ConnectTwice_Server_NonBlock() throws Exception {
         // ensure
         ensureServerOpen();
@@ -1476,17 +1620,18 @@ public class SocketChannelTest extends TestCase {
     /**
      * finish-->connect-->finish-->close
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
         ),
-        @TestTarget(
-          methodName = "finishConnect",
-          methodArgs = {}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
         )
     })
     public void testCFII_FinishFirst_NoServer_Block() throws Exception {
@@ -1522,18 +1667,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * finish-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_FinishFirst_NoServer_NonBlock() throws Exception {
         // ensure
@@ -1551,14 +1697,7 @@ public class SocketChannelTest extends TestCase {
         // connect
         assertFalse(this.channel1.connect(localAddr1));
         statusNotConnected_Pending();
-
-        try {
-            assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-            this.channel1.close();
-        } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
-        }
+        this.channel1.close();
 
         statusChannelClosed();
     }
@@ -1566,18 +1705,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * finish-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })    
     public void testCFII_FinishFirst_Server_Block() throws Exception {
         // ensure
@@ -1606,18 +1746,19 @@ public class SocketChannelTest extends TestCase {
     /**
      * finish-->connect-->finish-->close
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })    
     public void testCFII_FinishFirst_Server_NonBlock() throws Exception {
         // ensure
@@ -1641,15 +1782,13 @@ public class SocketChannelTest extends TestCase {
         this.channel1.close();
         statusChannelClosed();
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testCFII_Null() throws Exception {
         statusNotConnected_NotPending();
         try {
@@ -1659,24 +1798,14 @@ public class SocketChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              )
-    })
-    public void testCFII_UnsupportedType() throws Exception {
-        class SubSocketAddress extends SocketAddress {
-            private static final long serialVersionUID = 1L;
 
-            //empty
-            public SubSocketAddress() {
-                super();
-            }
-        }
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
+    public void testCFII_UnsupportedType() throws Exception {
         statusNotConnected_NotPending();
         SocketAddress newTypeAddress = new SubSocketAddress();
         try {
@@ -1686,15 +1815,13 @@ public class SocketChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testCFII_Unresolved() throws IOException {
         statusNotConnected_NotPending();
         InetSocketAddress unresolved = new InetSocketAddress(
@@ -1706,15 +1833,13 @@ public class SocketChannelTest extends TestCase {
             // OK.
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testCFII_EmptyHost() throws Exception {
         statusNotConnected_NotPending();
         ServerSocket server = new ServerSocket(0);
@@ -1727,21 +1852,19 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Verifies ClosedChannelException.",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        ),
-        @TestTarget(
-          methodName = "finishConnect",
-          methodArgs = {}
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies ClosedChannelException.",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
         ),
-        @TestTarget(
-          methodName = "configureBlocking",
-          methodArgs = {boolean.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies ClosedChannelException.",
+            method = "finishConnect",
+            args = {}
         )
     })
     public void testCFII_CloseFirst() throws Exception {
@@ -1770,18 +1893,20 @@ public class SocketChannelTest extends TestCase {
         }
         statusChannelClosed();
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
     })
     public void testCFII_StatusAfterFinish() throws Exception {
         // 1. close server, finish must return false, check the status
@@ -1795,7 +1920,6 @@ public class SocketChannelTest extends TestCase {
         } catch (ConnectException e) {
             // OK.
         }
-        assertFalse(this.channel1.isOpen());
 
         assertFalse(this.channel1.isOpen());
         assertTrue(this.channel1.isBlocking());
@@ -1807,11 +1931,11 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.connect(localAddr1));
         try {
             assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
-            this.channel1.close();
+            fail("Should throw IOException: Connection refused");
         } catch (ConnectException e) {
-            System.out.println(e.getMessage());
+            // OK
         }
+        statusChannelClosed();
 
         // 2. start server, finish usually return true, check the status
         ensureServerOpen();
@@ -1861,10 +1985,10 @@ public class SocketChannelTest extends TestCase {
         statusNotConnected_Pending();
         try {
             assertFalse(this.channel1.finishConnect());
-            statusNotConnected_Pending();
         } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
+            // OK
         }
+        ensureServerClosed();
     }
 
     private void connectServerNonBlock() throws Exception {
@@ -1887,6 +2011,7 @@ public class SocketChannelTest extends TestCase {
         // connect
         assertTrue(this.channel1.connect(localAddr1));
         statusConnected_NotPending();
+
         tryFinish();
     }
 
@@ -1939,15 +2064,12 @@ public class SocketChannelTest extends TestCase {
      * 
      * 'SocketChannelImpl.connect(SocketAddress)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "connect",
-          methodArgs = {java.net.SocketAddress.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "connect",
+        args = {java.net.SocketAddress.class}
+    )
     public void testCFII_Data_ConnectWithServer() throws Exception {
         ensureServerOpen();
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
@@ -1981,23 +2103,20 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'SocketChannelImpl.connect(SocketAddress)'
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              ),
-              @TestTarget(
-                methodName = "configureBlocking",
-                methodArgs = {boolean.class}
-              )
-      }) 
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        )
+    }) 
     public void testCFII_Data_ConnectWithServer_nonBlocking() throws Exception {
         ensureServerOpen();
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
@@ -2013,17 +2132,17 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isConnected());
         assertTrue(this.channel1.isConnectionPending());
         assertTrue(this.channel1.isOpen());
-        if (tryFinish()) {
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
+        assertTrue(tryFinish());
+        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
+        assertEquals(CAPACITY_NORMAL, this.channel1
+                .write(writeBufArr, 0, 1));
 
-            this.channel1.configureBlocking(false);
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw AlreadyConnectedException");
-            } catch (AlreadyConnectedException e) {
-                // correct
-            }
+        this.channel1.configureBlocking(false);
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw AlreadyConnectedException");
+        } catch (AlreadyConnectedException e) {
+            // correct
         }
 
         assertFalse(this.channel1.isRegistered());
@@ -2033,19 +2152,12 @@ public class SocketChannelTest extends TestCase {
     /*
      * Test method for 'SocketChannelImpl.finishConnect()'
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              ),
-              @TestTarget(
-                methodName = "configureBlocking",
-                methodArgs = {boolean.class}
-              )
-      }) 
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "finishConnect",
+        args = {}
+    )
     public void testCFII_Data_FinishConnect_nonBlocking() throws IOException {
         ensureServerOpen();
 
@@ -2067,38 +2179,43 @@ public class SocketChannelTest extends TestCase {
         assertTrue(this.channel1.isConnectionPending());
         assertTrue(this.channel1.isOpen());
         this.server1.accept();
-        if (tryFinish()) {
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw AlreadyConnectedException");
-            } catch (AlreadyConnectedException e) {
-                // correct
-            }
+        assertTrue(tryFinish());
+        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
+        assertEquals(CAPACITY_NORMAL, this.channel1
+                .write(writeBufArr, 0, 1));
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw AlreadyConnectedException");
+        } catch (AlreadyConnectedException e) {
+            // correct
         }
+
         assertFalse(this.channel1.isRegistered());
         tryFinish();
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "connect",
-                methodArgs = {java.net.SocketAddress.class}
-              ),
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              ),
-              @TestTarget(
-                methodName = "open",
-                methodArgs = {}
-              )
-      }) 
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "connect",
+            args = {java.net.SocketAddress.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "finishConnect",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies IOException",
+            method = "open",
+            args = {SocketAddress.class}
+        )
+    }) 
     public void testCFII_Data_FinishConnect_AddrSetServerStartLater()
-            throws IOException, InterruptedException {
+            throws IOException {
         ensureServerClosed();
         java.nio.ByteBuffer[] writeBufArr = new java.nio.ByteBuffer[1];
         writeBufArr[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
@@ -2142,39 +2259,32 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isConnected());
         ensureServerOpen();
         // cannot connect?
-        try {
-            assertFalse(this.channel1.finishConnect());
             assertFalse(this.channel1.isBlocking());
-            assertFalse(this.channel1.isConnected());
-            assertTrue(this.channel1.isConnectionPending());
-            assertTrue(this.channel1.isOpen());
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw ConnectionPendingException");
-            } catch (ConnectionPendingException e) {
-                // correct
-            }
-            this.channel1.configureBlocking(true);
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw ConnectionPendingException");
-            } catch (ConnectionPendingException e) {
-                // correct
-            }
-            tryFinish();
-        } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
-        }
-    }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              )
-      }) 
+        assertFalse(this.channel1.isConnected());
+        assertTrue(this.channel1.isConnectionPending());
+        assertTrue(this.channel1.isOpen());
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw ConnectionPendingException");
+        } catch (ConnectionPendingException e) {
+            // correct
+        }
+        this.channel1.configureBlocking(true);
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw ConnectionPendingException");
+        } catch (ConnectionPendingException e) {
+            // correct
+        }
+        tryFinish();
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "finishConnect",
+        args = {}
+    ) 
     public void testCFII_Data_FinishConnect_ServerStartLater()
             throws IOException {
         ensureServerClosed();
@@ -2209,43 +2319,32 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isConnected());
         ensureServerOpen();
         // cannot connect?
+        assertFalse(this.channel1.isBlocking());
+        assertFalse(this.channel1.isConnected());
+        assertTrue(this.channel1.isConnectionPending());
+        assertTrue(this.channel1.isOpen());
         try {
-            assertFalse(this.channel1.finishConnect());
-            assertFalse(this.channel1.isBlocking());
-            assertFalse(this.channel1.isConnected());
-            assertTrue(this.channel1.isConnectionPending());
-            assertTrue(this.channel1.isOpen());
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw ConnectionPendingException");
-            } catch (ConnectionPendingException e) {
-                // correct
-            }
-            this.channel1.configureBlocking(true);
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw ConnectionPendingException");
-            } catch (ConnectionPendingException e) {
-                // correct
-            }
-            tryFinish();
-        } catch (ConnectException e) {
-            // FIXME: assertEquals(e.getMessage(), "Connection refused");
-        }
-    }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "finishConnect",
-                methodArgs = {}
-              ),
-              @TestTarget(
-                methodName = "configureBlocking",
-                methodArgs = {boolean.class}
-              )
-      }) 
+            this.channel1.connect(localAddr1);
+            fail("Should throw ConnectionPendingException");
+        } catch (ConnectionPendingException e) {
+            // correct
+        }
+        this.channel1.configureBlocking(true);
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw ConnectionPendingException");
+        } catch (ConnectionPendingException e) {
+            // correct
+        }
+        tryFinish();
+    }
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "finishConnect",
+        args = {}
+    )
     public void testCFII_Data_FinishConnect_Blocking() throws IOException {
         ensureServerOpen();
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
@@ -2265,17 +2364,18 @@ public class SocketChannelTest extends TestCase {
         assertTrue(this.channel1.isConnected());
         assertFalse(this.channel1.isConnectionPending());
         assertTrue(this.channel1.isOpen());
-        if (tryFinish()) {
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
-            assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBufArr, 0, 1));
+        assertTrue(tryFinish());
+        assertEquals(CAPACITY_NORMAL, this.channel1.write(writeBuf));
+        assertEquals(CAPACITY_NORMAL, this.channel1
+                .write(writeBufArr, 0, 1));
 
-            try {
-                this.channel1.connect(localAddr1);
-                fail("Should throw AlreadyConnectedException");
-            } catch (AlreadyConnectedException e) {
-                // correct
-            }
+        try {
+            this.channel1.connect(localAddr1);
+            fail("Should throw AlreadyConnectedException");
+        } catch (AlreadyConnectedException e) {
+            // correct
         }
+
         assertFalse(this.channel1.isRegistered());
         tryFinish();
     }
@@ -2283,15 +2383,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * Regression test for Harmony-1947.
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Doesn't verify exceptions.",
-            targets = {
-              @TestTarget(
-                methodName = "finishConnect",                        
-                methodArgs = {}
-              )
-          })  
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exceptions.",
+        method = "finishConnect",
+        args = {}
+    )  
     public void test_finishConnect() throws Exception {
         SocketAddress address = new InetSocketAddress("localhost", 2046);
 
@@ -2315,9 +2412,14 @@ public class SocketChannelTest extends TestCase {
                 // finishConnect() blocks.
                 channel1.configureBlocking(true);
                 doneNonBlockingConnect = channel1.finishConnect();
+            } else {
+                fail("Non blocking connect was connected too fast." +
+                        "Could not test finishConnect().");
             }
             if (doneNonBlockingConnect) {
                 tryFinish();
+            } else {
+                fail("finishConnect() did not finish the connection.");
             }
             channel1.close();
         }
@@ -2325,7 +2427,7 @@ public class SocketChannelTest extends TestCase {
             serversocket.close();
         }
     }
-    
+
     // -------------------------------------------------------------------
     // End of original tests. Test method for CFII with real data.
     // -------------------------------------------------------------------
@@ -2333,16 +2435,13 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.SocketChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          }) 
-    public void test_readLjava_nio_ByteBuffer_Blocking() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    ) 
+    public void test_readLByteBuffer_Blocking() throws IOException {
         // initialize write content
         byte[] writeContent = new byte[CAPACITY_NORMAL];
         for (int i = 0; i < writeContent.length; i++) {
@@ -2375,7 +2474,10 @@ public class SocketChannelTest extends TestCase {
             // blocking read, it possibly returns 0 in some cases.
             assertTimeout(startTime, TIMEOUT);
         }
+
+        // assert read content
         assertEquals(CAPACITY_NORMAL, totalCount);
+        assertEquals(CAPACITY_NORMAL, readContent.position());
         readContent.flip();
         for (int i = 0; i < CAPACITY_NORMAL; i++) {
             assertEquals(writeContent[i], readContent.get());
@@ -2385,16 +2487,13 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.SocketChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          }) 
-    public void test_readLjava_nio_ByteBuffer_Nonblocking() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    ) 
+    public void test_readLByteBuffer_Nonblocking() throws IOException {
         // initialize write content
         byte[] writeContent = new byte[CAPACITY_NORMAL];
         for (int i = 0; i < writeContent.length; i++) {
@@ -2440,16 +2539,13 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.SocketChannel#write(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_wrtieLjava_nio_ByteBuffer_Blocking() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void test_writeLjava_nio_ByteBuffer_Blocking() throws IOException {
         // initialize write content
         ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
         for (int i = 0; i < CAPACITY_NORMAL; i++) {
@@ -2499,16 +2595,13 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.SocketChannel#write(ByteBuffer)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
-    public void test_wrtieLjava_nio_ByteBuffer_NonBlocking() throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    public void test_writeLjava_nio_ByteBuffer_NonBlocking() throws Exception {
         // initialize write content
         ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_NORMAL);
         for (int i = 0; i < CAPACITY_NORMAL; i++) {
@@ -2564,6 +2657,47 @@ public class SocketChannelTest extends TestCase {
         }
     }
 
+    /**
+     * @tests java.nio.channels.SocketChannel#read(ByteBuffer)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
+    @KnownFailure("Fxed on ToT")
+    public void test_writeLjava_nio_ByteBuffer_Nonblocking_HugeData() throws IOException {
+        // initialize write content
+        ByteBuffer writeContent = ByteBuffer.allocate(CAPACITY_HUGE);
+        for (int i = 0; i < CAPACITY_HUGE; i++) {
+            writeContent.put((byte) i);
+        }
+        writeContent.flip();
+
+        // establish connection
+        channel1.connect(localAddr1);
+        Socket acceptedSocket = server1.accept();
+
+        channel1.configureBlocking(false);
+        int writtenTotalCount = 0;
+        int writtenCount = 1;
+        long startTime = System.currentTimeMillis();
+        // use SocketChannel.write(ByteBuffer) to try to write CAPACITY_HUGE bytes
+        while (writtenTotalCount < CAPACITY_HUGE && writtenCount > 0) {
+            writtenCount = channel1.write(writeContent);
+            if (writtenCount == 0 && writtenTotalCount < CAPACITY_HUGE) {
+                assertEquals(0, channel1.write(writeContent));
+                break;
+            }
+            writtenTotalCount += writtenCount;
+            // if the channel could not finish writing in TIMEOUT ms, the
+            // test fails. It is used to guarantee the test never hangs even
+            // if there are bugs of SocketChannel implementation.
+            assertTimeout(startTime, TIMEOUT);
+        }
+    }
+
     /*
      * Fails if the difference between current time and start time is greater
      * than timeout.
@@ -2578,15 +2712,12 @@ public class SocketChannelTest extends TestCase {
     // -------------------------------------------------
     // Test for read/write but no real data expressed
     // -------------------------------------------------
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify all exceptions according to specification.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadByteBuffer() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
@@ -2608,9 +2739,8 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isBlocking());
         assertTrue(this.channel1.isConnectionPending());
         assertFalse(this.channel1.isConnected());
-        if (tryFinish()) {
-            assertEquals(0, this.channel1.read(readBuf));
-        }
+        assertTrue(tryFinish());
+        assertEquals(0, this.channel1.read(readBuf));
 
         this.channel1.close();
         try {
@@ -2620,15 +2750,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadByteBuffer_Direct() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer readBuf = java.nio.ByteBuffer
@@ -2650,9 +2778,8 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isBlocking());
         assertTrue(this.channel1.isConnectionPending());
         assertFalse(this.channel1.isConnected());
-        if (tryFinish()) {
-            assertEquals(0, this.channel1.read(readBuf));
-        }
+        assertTrue(tryFinish());
+        assertEquals(0, this.channel1.read(readBuf));
 
         this.channel1.close();
         try {
@@ -2662,15 +2789,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testReadByteBuffer_BufNull() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer readBuf = java.nio.ByteBuffer.allocate(0);
@@ -2683,36 +2808,25 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
         this.channel1.connect(localAddr1);
-        if (tryFinish()) {
-            try {
-                this.channel1.read((java.nio.ByteBuffer) null);
-                fail("Should throw NPE");
-            } catch (NullPointerException e) {
-                // correct
-            }
-            assertEquals(0, this.channel1.read(readBuf));
-        }
-        this.server1.close();
+        assertTrue(tryFinish());
         try {
-            channel1.read((java.nio.ByteBuffer) null);
+            this.channel1.read((java.nio.ByteBuffer) null);
             fail("Should throw NPE");
         } catch (NullPointerException e) {
             // correct
         }
+        assertEquals(0, this.channel1.read(readBuf));
     }
 
     /*
      * SocketChannelImpl.read(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testReadByteBufferArrayIntInt() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
@@ -2735,10 +2849,9 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isBlocking());
         assertTrue(this.channel1.isConnectionPending());
         assertFalse(this.channel1.isConnected());
-        if (tryFinish()) {
-            assertEquals(0, this.channel1.read(readBuf, 0, 1));
-            assertEquals(0, this.channel1.read(readBuf, 0, 2));
-        }
+        assertTrue(tryFinish());
+        assertEquals(0, this.channel1.read(readBuf, 0, 1));
+        assertEquals(0, this.channel1.read(readBuf, 0, 2));
 
         this.channel1.close();
         try {
@@ -2748,19 +2861,16 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    
+
     /*
      * SocketChannelImpl.read(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-          })    
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )    
     public void testReadByteBufferArrayIntInt_Direct() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
@@ -2783,10 +2893,9 @@ public class SocketChannelTest extends TestCase {
         assertFalse(this.channel1.isBlocking());
         assertTrue(this.channel1.isConnectionPending());
         assertFalse(this.channel1.isConnected());
-        if (tryFinish()) {
-            assertEquals(0, this.channel1.read(readBuf, 0, 1));
-            assertEquals(0, this.channel1.read(readBuf, 0, 2));
-        }
+        assertTrue(tryFinish());
+        assertEquals(0, this.channel1.read(readBuf, 0, 1));
+        assertEquals(0, this.channel1.read(readBuf, 0, 2));
 
         this.channel1.close();
         try {
@@ -2796,15 +2905,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testReadByteBufferArrayIntInt_BufNull() throws Exception {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[2];
@@ -2823,23 +2930,23 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
         this.channel1.connect(localAddr1);
-        if (tryFinish()) {
+        assertTrue(tryFinish());
 
-            try {
-                channel1.read(null, 0, 0);
-                fail("Should throw NPE");
-            } catch (NullPointerException e) {
-                // correct
-            }
-            try {
-                channel1.read(readBuf, 0, 2);
-                fail("Should throw NPE");
-            } catch (NullPointerException e) {
-                // correct
-            }
-
-            assertEquals(0, this.channel1.read(readBuf, 0, 1));
+        try {
+            channel1.read(null, 0, 0);
+            fail("Should throw NPE");
+        } catch (NullPointerException e) {
+            // correct
+        }
+        try {
+            channel1.read(readBuf, 0, 2);
+            fail("Should throw NPE");
+        } catch (NullPointerException e) {
+            // correct
         }
+
+        assertEquals(0, this.channel1.read(readBuf, 0, 1));
+
         this.channel1.close();
         try {
             channel1.read(null, 0, 1);
@@ -2848,15 +2955,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testWriteByteBuffer() throws IOException {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
@@ -2887,16 +2992,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Doesn't verify AsynchronousCloseException, " +
-                    "ClosedByInterruptException.",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify AsynchronousCloseException, ClosedByInterruptException.",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testWriteByteBuffer_Direct() throws IOException {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer
@@ -2927,15 +3029,13 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer.class}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void testWriteByteBuffer_BufNull() throws IOException {
         assertTrue(this.server1.isBound());
         java.nio.ByteBuffer writeBuf = java.nio.ByteBuffer.allocate(0);
@@ -2952,16 +3052,13 @@ public class SocketChannelTest extends TestCase {
     /*
      * SocketChannelImpl.write(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "Doesn't verify AsynchronousCloseException, " +
-            "ClosedByInterruptException.",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify AsynchronousCloseException," +
+                "ClosedByInterruptException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testWriteByteBufferArrayIntInt() throws IOException {
         java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
         writeBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
@@ -2990,7 +3087,7 @@ public class SocketChannelTest extends TestCase {
         assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
         this.channel1.close();
         try {
-            channel1.write(writeBuf);
+            channel1.write(writeBuf, 0, 1);
             fail("Should throw ClosedChannelException");
         } catch (ClosedChannelException e) {
             // correct
@@ -3000,15 +3097,12 @@ public class SocketChannelTest extends TestCase {
     /*
      * SocketChannelImpl.write(ByteBuffer[], int, int)'
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testWriteByteBufferArrayIntInt_Direct() throws IOException {
         java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[2];
         writeBuf[0] = java.nio.ByteBuffer.allocateDirect(CAPACITY_NORMAL);
@@ -3037,21 +3131,19 @@ public class SocketChannelTest extends TestCase {
         assertEquals(CAPACITY_NORMAL * 2, this.channel1.write(writeBuf, 0, 2));
         this.channel1.close();
         try {
-            channel1.write(writeBuf);
+            channel1.write(writeBuf, 0 ,1);
             fail("Should throw ClosedChannelException");
         } catch (ClosedChannelException e) {
             // correct
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testWriteByteBufferArrayIntInt_BufNull() throws IOException {
         java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[0];
 
@@ -3076,6 +3168,7 @@ public class SocketChannelTest extends TestCase {
         } catch (NullPointerException e) {
             // correct
         }
+        writeBuf[0] = java.nio.ByteBuffer.allocate(CAPACITY_NORMAL);
         try {
             this.channel1.write(writeBuf, 0, 2);
             fail("Should throw IndexOutOfBoundsException");
@@ -3090,21 +3183,20 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies IndexOutOfBoundsException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException.",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testWriteByteBufferArrayIntInt_SizeError() throws IOException {
-        java.nio.ByteBuffer[] writeBuf = new java.nio.ByteBuffer[0];
+        java.nio.ByteBuffer[] writeBuf = 
+                {java.nio.ByteBuffer.allocate(CAPACITY_NORMAL)};
 
         this.channel1.connect(localAddr1);
         try {
-            this.channel1.write(null, -1, 1);
+            this.channel1.write(writeBuf, -1, 1);
             fail("Should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
@@ -3116,36 +3208,26 @@ public class SocketChannelTest extends TestCase {
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
-        writeBuf = new java.nio.ByteBuffer[1];
-        try {
-            this.channel1.write(writeBuf, 2, 1);
-            fail("Should throw IndexOutOfBoundsException");
-        } catch (IndexOutOfBoundsException e) {
-            // correct
-        }
         try {
-            this.channel1.write(writeBuf, 2, -1);
+            this.channel1.write(writeBuf, 1, 1);
             fail("Should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
-        this.server1.close();
         try {
-            channel1.read(null, -1, -1);
+            this.channel1.write(writeBuf, 0, 2);
             fail("Should throw IndexOutOfBoundsException");
         } catch (IndexOutOfBoundsException e) {
             // correct
         }
     }
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "write",
-                methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-              )
-          })
+
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void testReadByteBufferArrayIntInt_SizeError() throws IOException {
         java.nio.ByteBuffer[] readBuf = new java.nio.ByteBuffer[0];
 
@@ -3184,68 +3266,121 @@ public class SocketChannelTest extends TestCase {
             // correct
         }
     }
-    
-    /* 
+
+    /*
      * ==========================================================================
      * Tests for read/write real data
      * ==========================================================================
-     */ 
-        
+     */
+
+    /**
+     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    ) 
+    public void test_read$LByteBuffer_blocking() throws Exception {
+        assert_read$LByteBuffer(true);
+    }
 
     /**
-     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[])
-     */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          }) 
-    public void test_read$LByteBuffer() throws IOException {
-        MockSocketChannel sc = new MockSocketChannel(null);
-        ByteBuffer [] byteBufferArray = { ByteBuffer.allocate(1), ByteBuffer.allocate(1)};
-        // Verify that calling read(ByteBuffer[]) leads to the method
-        // read(ByteBuffer[], int, int) being called with a 0 for the
-        // second parameter and targets.length as the third parameter.
-        sc.read(byteBufferArray);
-        assertTrue(sc.isReadCalled);
+     * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    ) 
+    public void test_read$LByteBuffer_nonblocking() throws Exception {
+        assert_read$LByteBuffer(false);
+    }
+
+    private void assert_read$LByteBuffer(boolean isBlocking) throws IOException {
+        // initialize write content
+        byte[] writeContent = new byte[CAPACITY_NORMAL * 2];
+        for (int i = 0; i < CAPACITY_NORMAL * 2; i++) {
+            writeContent[i] = (byte) i;
+        }
+        ByteBuffer[] readContents = new ByteBuffer[2];
+        readContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
+        readContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL + 1);
+        // establish connection
+        channel1.connect(localAddr1);
+        Socket acceptedSocket = server1.accept();
+        // use OutputStream.write to send CAPACITY_NORMAL * 2 bytes data
+        OutputStream out = acceptedSocket.getOutputStream();
+        out.write(writeContent);
+        // use close to guarantee all data is sent
+        acceptedSocket.close();
+        // configure block/nonblock mode
+        channel1.configureBlocking(isBlocking);
+        long startTime = System.currentTimeMillis();
+        long totalRead = 0;
+        long countRead = 0;
+
+        while (totalRead <= CAPACITY_NORMAL * 2) {
+            countRead = channel1.read(readContents);
+            if (0 == countRead && !readContents[1].hasRemaining()) {
+                // read returns 0 because readContents is full
+                break;
+            }
+            if (EOF == countRead) {
+                break;
+            }
+            totalRead += countRead;
+            // if the channel could not finish reading in TIMEOUT ms, the
+            // test fails. It is used to guarantee the test never hangs even
+            // if there are bugs of SocketChannel implementation. For
+            // blocking read, it possibly returns 0 in some cases.
+            assertTimeout(startTime, TIMEOUT);
+        }
+
+        // assert total bytes read and the position of ByteBuffers
+        assertEquals(CAPACITY_NORMAL * 2, totalRead);
+        assertEquals(CAPACITY_NORMAL, readContents[0].position());
+        assertEquals(CAPACITY_NORMAL, readContents[1].position());
+        // assert read content
+        readContents[0].flip();
+        readContents[1].flip();
+        for (int i = 0; i < CAPACITY_NORMAL; i++) {
+            assertEquals(writeContent[i], readContents[0].get());
+        }
+        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
+            assertEquals(writeContent[i], readContents[1].get());
+        }
     }
+
     /**
      * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
-     */  
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          }) 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    ) 
     public void test_read$LByteBufferII_blocking() throws Exception {
-        assert_read$LByteBuffer(true);
+        assert_read$LByteBufferII(true);
     }
- 
+
     /**
      * @tests java.nio.channels.SocketChannel#read(ByteBuffer[],int,int)
-     */  
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          }) 
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    ) 
     public void test_read$LByteBufferII_nonblocking() throws Exception {
-        assert_read$LByteBuffer(false);
+        assert_read$LByteBufferII(false);
     }
 
-    private void assert_read$LByteBuffer(boolean isBlocking) throws IOException {
+    private void assert_read$LByteBufferII(boolean isBlocking) throws IOException {
         // initialize write content
         byte[] writeContent = new byte[CAPACITY_NORMAL * 2];
         for (int i = 0; i < CAPACITY_NORMAL * 2; i++) {
@@ -3284,7 +3419,7 @@ public class SocketChannelTest extends TestCase {
             // blocking read, it possibly returns 0 in some cases.
             assertTimeout(startTime, TIMEOUT);
         }
-        
+
         // assert total bytes read and the position of ByteBuffers
         assertEquals(CAPACITY_NORMAL * 2, totalRead);
         assertEquals(CAPACITY_NORMAL, readContents[0].position());
@@ -3298,38 +3433,31 @@ public class SocketChannelTest extends TestCase {
         for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
             assertEquals(writeContent[i], readContents[1].get());
         }
-    } 
- 
+    }
+
     /**
      * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
-     */ 
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void test_write$LByteBufferII_blocking() throws Exception {
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_write$LByteBuffer_blocking() throws Exception {
         assert_write$LByteBuffer(true);
     }
- 
+
     /**
      * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
-    public void test_write$LByteBufferII_nonblocking()
-            throws Exception {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class}
+    )
+    public void test_write$LByteBuffer_nonblocking() throws Exception {
         assert_write$LByteBuffer(false);
     }
 
@@ -3353,6 +3481,88 @@ public class SocketChannelTest extends TestCase {
         // set blocking/nonblocking mode
         channel1.configureBlocking(isBlocking);
 
+        assertEquals(2 * CAPACITY_NORMAL, channel1.write(writeContents));
+
+        // assert written count and ByteBuffer position
+        assertEquals(CAPACITY_NORMAL, writeContents[0].position());
+        assertEquals(CAPACITY_NORMAL, writeContents[1].position());
+        // use close to guarantee all data is sent
+        channel1.close();
+        InputStream in = acceptedSocket.getInputStream();
+        byte[] readContent = new byte[CAPACITY_NORMAL * 2 + 1];
+        int totalCount = 0;
+        int count = 0;
+        // if the channel could not finish reading in TIMEOUT ms, the test
+        // fails. It is used to guarantee the test never hangs even if there
+        // are bugs of SocketChannel implementation.
+        acceptedSocket.setSoTimeout(TIMEOUT);
+        // use InputStream.read to read data.
+        while (totalCount <= CAPACITY_NORMAL) {
+            count = in.read(readContent, totalCount, readContent.length
+                    - totalCount);
+            if (EOF == count) {
+                break;
+            }
+            totalCount += count;
+        }
+        // assert read content
+        assertEquals(CAPACITY_NORMAL * 2, totalCount);
+        writeContents[0].flip();
+        writeContents[1].flip();
+        for (int i = 0; i < CAPACITY_NORMAL; i++) {
+            assertEquals(writeContents[0].get(), readContent[i]);
+        }
+        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
+            assertEquals(writeContents[1].get(), readContent[i]);
+        }
+    }
+
+    /**
+     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void test_write$LByteBufferII_blocking() throws Exception {
+        assert_write$LByteBufferII(true);
+    }
+
+    /**
+     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[],int,int)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
+    public void test_write$LByteBufferII_nonblocking() throws Exception {
+        assert_write$LByteBufferII(false);
+    }
+
+    private void assert_write$LByteBufferII(boolean isBlocking)
+            throws IOException {
+        // initialize write contents
+        ByteBuffer writeContents[] = new ByteBuffer[2];
+        writeContents[0] = ByteBuffer.allocate(CAPACITY_NORMAL);
+        writeContents[1] = ByteBuffer.allocate(CAPACITY_NORMAL);
+        for (int i = 0; i < CAPACITY_NORMAL; i++) {
+            writeContents[0].put((byte) i);
+        }
+        for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
+            writeContents[1].put((byte) i);
+        }
+        writeContents[0].flip();
+        writeContents[1].flip();
+        // establish connection
+        channel1.connect(localAddr1);
+        Socket acceptedSocket = server1.accept();
+        // set blocking/nonblocking mode
+        channel1.configureBlocking(isBlocking);
+
         assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 0, 1));
         assertEquals(CAPACITY_NORMAL, channel1.write(writeContents, 1, 1));
 
@@ -3388,38 +3598,23 @@ public class SocketChannelTest extends TestCase {
         for (int i = CAPACITY_NORMAL; i < CAPACITY_NORMAL * 2; i++) {
             assertEquals(writeContents[1].get(), readContent[i]);
         }
-    } 
-    
-    /**
-     * @tests java.nio.channels.SocketChannel#write(ByteBuffer[])
-     */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class}
+    }
+
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "socket",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            clazz = SelectableChannel.class,
+            method = "configureBlocking",
+            args = {boolean.class}
         )
     })
-    public void test_write$LByteBuffer() throws IOException {
-        MockSocketChannel sc = new MockSocketChannel(null);
-        ByteBuffer [] byteBufferArray = { ByteBuffer.allocate(1), ByteBuffer.allocate(1)};
-        // Verify that calling write(ByteBuffer[]) leads to the method
-        // write(ByteBuffer[], int, int) being called with a 0 for the
-        // second parameter and sources.length as the third parameter.
-        sc.write(byteBufferArray);
-        assertTrue(sc.isWriteCalled);
-    }
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "Verifies IllegalBlockingModeException.",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
     public void testSocket_configureblocking() throws IOException {
         byte[] serverWBuf = new byte[CAPACITY_NORMAL];
         for (int i = 0; i < serverWBuf.length; i++) {
@@ -3450,15 +3645,12 @@ public class SocketChannelTest extends TestCase {
      * @tests SocketChannel#read(ByteBuffer[], int, int) when remote server
      *        closed
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_socketChannel_read_ByteBufferII_remoteClosed()
             throws Exception {
         // regression 1 for HARMONY-549
@@ -3467,7 +3659,7 @@ public class SocketChannelTest extends TestCase {
         SocketChannel sc = SocketChannel.open();
         sc.connect(localAddr2);
         ssc.accept().close();
-        ByteBuffer[] buf = { ByteBuffer.allocate(10) };
+        ByteBuffer[] buf = {ByteBuffer.allocate(10)};
         assertEquals(-1, sc.read(buf, 0, 1));
         ssc.close();
         sc.close();
@@ -3476,15 +3668,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannel#write(ByteBuffer[], int, int)
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_socketChannel_write_ByteBufferII() throws Exception {
         // regression 2 for HARMONY-549
         ServerSocketChannel ssc = ServerSocketChannel.open();
@@ -3492,7 +3681,7 @@ public class SocketChannelTest extends TestCase {
         SocketChannel sc = SocketChannel.open();
         sc.connect(localAddr2);
         SocketChannel sock = ssc.accept();
-        ByteBuffer[] buf = { ByteBuffer.allocate(10), null };
+        ByteBuffer[] buf = {ByteBuffer.allocate(10), null};
         try {
             sc.write(buf, 0, 2);
             fail("should throw NPE");
@@ -3508,15 +3697,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannel#read(ByteBuffer[], int, int) with a null ByteBuffer
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "read",
-          methodArgs = {java.nio.ByteBuffer[].class, int.class, int.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )
     public void test_socketChannel_read_ByteBufferII_bufNULL() throws Exception {
         // regression 3 for HARMONY-549
         ServerSocketChannel ssc = ServerSocketChannel.open();
@@ -3540,19 +3726,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannel#write(ByteBuffer) after close
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        ),
-        @TestTarget(
-          methodName = "close",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_socketChannel_write_close() throws Exception {
         // regression 4 for HARMONY-549
         ServerSocketChannel ssc = ServerSocketChannel.open();
@@ -3575,15 +3754,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannel#write(ByteBuffer) if position is not zero
      */
-    @TestInfo(
-      level = TestLevel.PARTIAL,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "write",
-          methodArgs = {java.nio.ByteBuffer.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "write",
+        args = {java.nio.ByteBuffer.class}
+    )
     public void test_socketChannel_write_ByteBuffer_posNotZero()
             throws Exception {
         // regression 5 for HARMONY-549
@@ -3607,20 +3783,17 @@ public class SocketChannelTest extends TestCase {
             assertEquals(read[i], write[i + 2]);
         }
     }
-    
+
     /**
      * @tests SocketChannelImpl#read(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Doesn't verify exceptions.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          }) 
-    public void test_read_$ByteBuffer_Blocking() throws IOException {
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Doesn't verify exceptions.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    ) 
+    public void test_read$LByteBuffer_Blocking() throws IOException {
         // regression test for Harmony-728
         byte[] data = new byte[CAPACITY_NORMAL];
         for (int i = 0; i < CAPACITY_NORMAL; i++) {
@@ -3640,6 +3813,8 @@ public class SocketChannelTest extends TestCase {
         } finally {
             if (null != socket) {
                 socket.close();
+            } else {
+                fail();
             }
         }
     }
@@ -3647,16 +3822,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannelImpl#socket().getOutputStream().read
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "Verifies IllegalBlockingModeException, " +
-                    "NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IllegalBlockingModeException, NullPointerException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_getOutputStream_nonBlocking_read_Exception()
             throws IOException {
         channel1.connect(this.localAddr1);
@@ -3711,16 +3882,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannelImpl#socket().getOutputStream().read
      */
-    @TestInfo(
-          level = TestLevel.PARTIAL_OK,
-          purpose = "Verifies NullPointerException, ClosedChannelException, " +
-                "IndexOutOfBoundsException.",
-          targets = {
-            @TestTarget(
-              methodName = "socket",
-              methodArgs = {}
-            )
-        })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, ClosedChannelException, IndexOutOfBoundsException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_getOutputStream_blocking_read_Exception()
             throws IOException {
         channel1.connect(this.localAddr1);
@@ -3774,16 +3941,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannelImpl#socket().getOutputStream().write
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "Verifies NullPointerException, " +
-                    "IllegalBlockingModeException.",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, IllegalBlockingModeException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_getOutputStream_nonBlocking_write_Exception()
             throws IOException {
         channel1.connect(this.localAddr1);
@@ -3850,16 +4013,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannelImpl#socket().getOutputStream().write
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "Verifies NullPointerException, " +
-                    "IndexOutOfBoundsException, ClosedChannelException.",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, IndexOutOfBoundsException, ClosedChannelException.",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_getOutputStream_blocking_write_Exception()
             throws IOException {
         channel1.connect(this.localAddr1);
@@ -3913,15 +4072,12 @@ public class SocketChannelTest extends TestCase {
     /**
      * @tests SocketChannelImpl#socket().getOutputStream().write(int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL_OK,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "socket",
-                methodArgs = {}
-              )
-          })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "socket",
+        args = {}
+    )
     public void test_socket_getOutputStream_write_oneByte()
             throws IOException {
 
@@ -3940,12 +4096,12 @@ public class SocketChannelTest extends TestCase {
         os.write(MAGIC);
         channel1.close();
 
-        int lastByte =  in.read();
+        int lastByte = in.read();
         if (lastByte == -1) {
             fail("Server received nothing. Expected 1 byte.");
         } else if (lastByte != MAGIC) {
-            fail("Server received wrong single byte: " + lastByte +
-                 ", expected: " + MAGIC);
+            fail("Server received wrong single byte: " + lastByte
+                    + ", expected: " + MAGIC);
         }
 
         lastByte = in.read();
@@ -3954,14 +4110,17 @@ public class SocketChannelTest extends TestCase {
         }
     }
 
-    class MockSocketChannel extends SocketChannel{
-        
+    class MockSocketChannel extends SocketChannel {
+
         private boolean isWriteCalled = false;
-        
+
         private boolean isReadCalled = false;
-        
-        public MockSocketChannel(SelectorProvider provider){
+
+        private boolean isConstructorCalled = false;
+
+        public MockSocketChannel(SelectorProvider provider) {
             super(provider);
+            isConstructorCalled = true;
         }
 
         public Socket socket() {
@@ -3988,11 +4147,12 @@ public class SocketChannelTest extends TestCase {
             return 0;
         }
 
-        public long read(ByteBuffer[] targets, int offset, int length) throws IOException {
+        public long read(ByteBuffer[] targets, int offset, int length)
+                throws IOException {
             // Verify that calling read(ByteBuffer[]) leads to the method
             // read(ByteBuffer[], int, int) being called with a 0 for the
             // second parameter and targets.length as the third parameter.
-            if(0 == offset && length == targets.length){
+            if (0 == offset && length == targets.length) {
                 isReadCalled = true;
             }
             return 0;
@@ -4002,11 +4162,12 @@ public class SocketChannelTest extends TestCase {
             return 0;
         }
 
-        public long write(ByteBuffer[] sources, int offset, int length) throws IOException {
+        public long write(ByteBuffer[] sources, int offset, int length)
+                throws IOException {
             // Verify that calling write(ByteBuffer[]) leads to the method
             // write(ByteBuffer[], int, int) being called with a 0 for the
             // second parameter and sources.length as the third parameter.
-            if(0 == offset && length == sources.length){
+            if (0 == offset && length == sources.length) {
                 isWriteCalled = true;
             }
             return 0;
@@ -4016,9 +4177,18 @@ public class SocketChannelTest extends TestCase {
             // empty
         }
 
-        protected void implConfigureBlocking(boolean blockingMode) throws IOException {
-            // empty            
+        protected void implConfigureBlocking(boolean blockingMode)
+                throws IOException {
+            // empty
         }
-        
-    }   
+    }
+
+    class SubSocketAddress extends SocketAddress {
+        private static final long serialVersionUID = 1L;
+
+        // empty
+        public SubSocketAddress() {
+            super();
+        }
+    }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SourceChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SourceChannelTest.java
index 9225d0a..ca713c7 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SourceChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/SourceChannelTest.java
@@ -16,19 +16,33 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestInfo;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTargets;
 
 import java.io.IOException;
 import java.nio.ByteBuffer;
+import java.nio.channels.AsynchronousCloseException;
+import java.nio.channels.ClosedByInterruptException;
 import java.nio.channels.ClosedChannelException;
 import java.nio.channels.Pipe;
 import java.nio.channels.SelectionKey;
+import java.nio.channels.Pipe.SourceChannel;
+import java.nio.channels.spi.SelectorProvider;
 
 import junit.framework.TestCase;
-@TestTargetClass(java.nio.channels.Pipe.SourceChannel.class)
+@TestTargetClass(
+    value = java.nio.channels.Pipe.SourceChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.SUFFICIENT,
+            notes = "AsynchronousCloseException can not easily be tested",
+            method = "read",
+            args = {java.nio.ByteBuffer[].class}
+        ) 
+    }
+)
 /**
  * Tests for java.nio.channels.Pipe.SourceChannel
  */
@@ -61,15 +75,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#validOps()
      */
-    @TestInfo(
-            level = TestLevel.COMPLETE,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "validOps",                        
-                methodArgs = {}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "validOps",
+        args = {}
+    )   
     public void test_validOps() {
         assertEquals(SelectionKey.OP_READ, source.validOps());
     }
@@ -77,15 +88,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )   
     public void test_read_LByteBuffer_DataAvailable() throws IOException {
         // if anything can read, read method will not block
         sink.write(ByteBuffer.allocate(1));
@@ -96,15 +104,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })       
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )       
     public void test_read_LByteBuffer_Exception() throws IOException {
         ByteBuffer nullBuf = null;
         try {
@@ -118,15 +123,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })       
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )       
     public void test_read_LByteBuffer_SinkClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         sink.write(buffer);
@@ -145,16 +147,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies ClosedChannelException, " +
-                    "NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException, NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )   
     public void test_read_LByteBuffer_SourceClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         source.close();
@@ -177,8 +175,10 @@ public class SourceChannelTest extends TestCase {
         try {
             source.read(nullBuf);
             fail("should throw NullPointerException");
+        } catch (ClosedChannelException e) {
+            // expected on RI
         } catch (NullPointerException e) {
-            // expected
+            // expected on Harmony/Android
         }
         
         ByteBuffer[] bufArray = null; 
@@ -201,15 +201,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer[])
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_read_$LByteBuffer() throws IOException {
         ByteBuffer[] bufArray = { buffer, positionedBuffer };
         boolean[] sinkBlockingMode = { true, true, false, false };
@@ -261,15 +258,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_read_$LByteBuffer_Exception() throws IOException {
         ByteBuffer[] nullBufArrayRef = null;
         try {
@@ -301,15 +295,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_read_$LByteBuffer_SinkClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         ByteBuffer[] readBufArray = { readBuf };
@@ -330,15 +321,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies ClosedChannelException, NullPointerException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedChannelException, NullPointerException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )     
     public void test_read_$LByteBuffer_SourceClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         ByteBuffer[] readBufArray = { readBuf };
@@ -380,15 +368,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer[], int, int)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })     
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )     
     public void test_read_$LByteBufferII() throws IOException {
         ByteBuffer[] bufArray = { buffer, positionedBuffer };
         boolean[] sinkBlockingMode = { true, true, false, false };
@@ -440,16 +425,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies NullPointerException, " +
-                    "IndexOutOfBoundsException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies NullPointerException, IndexOutOfBoundsException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )   
     public void test_read_$LByteBufferII_Exception() throws IOException {
 
         ByteBuffer[] nullBufArrayRef = null;
@@ -522,15 +503,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )   
     public void test_read_$LByteBufferII_SinkClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         ByteBuffer[] readBufArray = { readBuf };
@@ -550,16 +528,12 @@ public class SourceChannelTest extends TestCase {
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "Verifies IndexOutOfBoundsException, " +
-                    "ClosedChannelException.",
-            targets = {
-              @TestTarget(
-                methodName = "read",                        
-                methodArgs = {ByteBuffer[].class, int.class, int.class}
-              )
-          })   
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies IndexOutOfBoundsException, ClosedChannelException.",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class, int.class, int.class}
+    )   
     public void test_read_$LByteBufferII_SourceClosed() throws IOException {
         ByteBuffer readBuf = ByteBuffer.allocate(BUFFER_SIZE);
         ByteBuffer[] readBufArray = { readBuf };
@@ -648,19 +622,100 @@ public class SourceChannelTest extends TestCase {
 
     /**
      * @tests java.nio.channels.Pipe.SourceChannel#close()
+     * @tests {@link java.nio.channels.Pipe.SourceChannel#isOpen()}
      */
-    @TestInfo(
-            level = TestLevel.PARTIAL,
-            purpose = "",
-            targets = {
-              @TestTarget(
-                methodName = "close",                        
-                methodArgs = {}
-              )
-          })     
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
+        ),@TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "isOpen",
+            args = {}
+        )
+    })    
     public void test_close() throws IOException {
+        assertTrue(sink.isOpen());
         sink.close();
         assertFalse(sink.isOpen());
     }
 
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "SourceChannel",
+        args = {java.nio.channels.spi.SelectorProvider.class}
+    )
+    public void testConstructor() throws IOException {
+        SourceChannel channel =
+                SelectorProvider.provider().openPipe().source();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+        channel = Pipe.open().source();
+        assertNotNull(channel);
+        assertSame(SelectorProvider.provider(),channel.provider());
+    }
+
+    /**
+     * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "Verifies ClosedByInterruptException",
+        method = "read",
+        args = {java.nio.ByteBuffer[].class}
+    )    
+    public void test_read_LByteBuffer_mutliThread_interrupt() throws Exception {
+
+        source.configureBlocking(true);
+
+        Thread thread = new Thread() {
+            public void run() {
+                try {
+                    source.read(ByteBuffer.allocate(10));
+                    fail("should have thrown a ClosedByInterruptException.");
+                } catch (ClosedByInterruptException e) {
+                    // expected
+                    return;
+                } catch (IOException e) {
+                    fail("should throw a ClosedByInterruptException but " +
+                            "threw " + e.getClass() + ": " + e.getMessage());
+                }
+            }
+        };
+        
+        thread.start();
+        Thread.currentThread().sleep(500);
+        thread.interrupt();
+        
+    }
+
+    /**
+     * @tests java.nio.channels.Pipe.SourceChannel#read(ByteBuffer)
+     */
+    public void disabled_test_read_LByteBuffer_mutliThread_close() throws Exception {
+
+        ByteBuffer sourceBuf = ByteBuffer.allocate(1000);
+        source.configureBlocking(true);
+
+        new Thread() {
+            public void run() {
+                try {
+                    Thread.currentThread().sleep(500);
+                    source.close();
+                } catch (Exception e) {
+                    //ignore
+                }
+            }
+        }.start();
+        try {
+            source.read(sourceBuf);
+            fail("should throw AsynchronousCloseException");
+        } catch (AsynchronousCloseException e) {
+            // ok
+        }
+    }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnresolvedAddressExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnresolvedAddressExceptionTest.java
index ff9227e..fe3417f 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnresolvedAddressExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnresolvedAddressExceptionTest.java
@@ -15,9 +15,9 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.channels.UnresolvedAddressException;
@@ -35,15 +35,20 @@ public class UnresolvedAddressExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationSelf",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "UnresolvedAddressException",
+            args = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new UnresolvedAddressException());
@@ -52,15 +57,20 @@ public class UnresolvedAddressExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
+    @TestTargets({
+        @TestTargetNew(
             level = TestLevel.COMPLETE,
-            purpose = "Verifies serialization/deserialization compatibility.",
-            targets = {
-              @TestTarget(
-                methodName = "!SerializationGolden",
-                methodArgs = {}
-              )
-          })
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "UnresolvedAddressException",
+            args = {}
+        )
+    })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new UnresolvedAddressException());
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnsupportedAddressTypeExceptionTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnsupportedAddressTypeExceptionTest.java
index 7dd0508..442fc1e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnsupportedAddressTypeExceptionTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/UnsupportedAddressTypeExceptionTest.java
@@ -15,9 +15,9 @@
  */
 package org.apache.harmony.nio.tests.java.nio.channels;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.channels.UnsupportedAddressTypeException;
@@ -35,15 +35,20 @@ public class UnsupportedAddressTypeExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationSelf",
-                  methodArgs = {}
-                )
-            })    
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationSelf",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "UnsupportedAddressTypeException",
+            args = {}
+        )
+    })    
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new UnsupportedAddressTypeException());
@@ -52,15 +57,20 @@ public class UnsupportedAddressTypeExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
-    @TestInfo(
-              level = TestLevel.COMPLETE,
-              purpose = "Verifies serialization/deserialization compatibility.",
-              targets = {
-                @TestTarget(
-                  methodName = "!SerializationGolden",
-                  methodArgs = {}
-                )
-            })        
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "!SerializationGolden",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "Verifies serialization/deserialization compatibility.",
+            method = "UnsupportedAddressTypeException",
+            args = {}
+        )
+    })        
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this,
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractInterruptibleChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractInterruptibleChannelTest.java
index a5af1fa..d81248e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractInterruptibleChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractInterruptibleChannelTest.java
@@ -16,9 +16,9 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.io.IOException;
@@ -26,19 +26,34 @@ import java.nio.channels.AsynchronousCloseException;
 import java.nio.channels.spi.AbstractInterruptibleChannel;
 
 import junit.framework.TestCase;
-@TestTargetClass(AbstractInterruptibleChannel.class)
+@TestTargetClass(
+    value = AbstractInterruptibleChannel.class,
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "AbstractInterruptibleChannel",
+            args = {}
+        )
+    }
+)
 public class AbstractInterruptibleChannelTest extends TestCase {
     
     /**
      * @tests AbstractInterruptibleChannel#close()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "close",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "isOpen",
+            args = {}
         )
     })
     public void test_close() throws IOException {
@@ -53,17 +68,18 @@ public class AbstractInterruptibleChannelTest extends TestCase {
     /**
      * @tests AbstractInterruptibleChannel#begin/end()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "begin",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "begin",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "end",
-          methodArgs = {boolean.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "end",
+            args = {boolean.class}
         )
     })
     public void test_begin_end() throws IOException {
@@ -105,21 +121,24 @@ public class AbstractInterruptibleChannelTest extends TestCase {
     /**
      * @tests AbstractInterruptibleChannel#close/begin/end()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "begin",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "begin",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "end",
-          methodArgs = {boolean.class}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "end",
+            args = {boolean.class}
         ),
-        @TestTarget(
-          methodName = "close",
-          methodArgs = {}
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
         )
     })
     public void test_close_begin_end() throws IOException {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectableChannelTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectableChannelTest.java
index cf68b8e..c81efa2 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectableChannelTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectableChannelTest.java
@@ -16,10 +16,11 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestTargetNew;
 
 import java.io.IOException;
 import java.nio.channels.ClosedChannelException;
@@ -34,6 +35,8 @@ import java.nio.channels.spi.SelectorProvider;
 
 import junit.framework.TestCase;
 
+import org.apache.harmony.nio.tests.java.nio.channels.spi.AbstractSelectorTest.MockSelectorProvider;
+
 /**
  * Tests for AbstractSelectableChannel 
  */
@@ -52,17 +55,35 @@ public class AbstractSelectableChannelTest extends TestCase {
             testChannel.close();
         }
     }
+    
+    /**
+     * @tests AbstractSelectableChannel()
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "AbstractSelectableChannel",
+        args = {SelectorProvider.class}
+    )
+    public void test_Constructor_LSelectorProvider() throws Exception {
+        assertSame(SelectorProvider.provider(), testChannel.provider());
+    }
 
     /**
      * @tests AbstractSelectableChannel#implCloseChannel()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "implCloseChannel",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "implCloseChannel",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "implCloseSelectableChannel",
+            args = {}
         )
     })
     public void test_implClose() throws IOException {
@@ -88,15 +109,12 @@ public class AbstractSelectableChannelTest extends TestCase {
     /**
      * @tests AbstractSelectableChannel#provider()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "provider",
+        args = {}
+    )
     public void test_provider() {
         SelectorProvider provider = testChannel.provider();
         assertSame(SelectorProvider.provider(), provider);
@@ -108,15 +126,12 @@ public class AbstractSelectableChannelTest extends TestCase {
     /**
      * @tests AbstractSelectableChannel#isBlocking()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isBlocking",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "isBlocking",
+        args = {}
+    )
     public void test_isBlocking() throws IOException {
         assertTrue(testChannel.isBlocking());
         testChannel.configureBlocking(false);
@@ -129,15 +144,12 @@ public class AbstractSelectableChannelTest extends TestCase {
      * 
      * @tests AbstractSelectableChannel#blockingLock()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "blockingLock",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "blockingLock",
+        args = {}
+    )
     public void test_blockingLock() {
         Object gotObj = testChannel.blockingLock();
         assertNotNull(gotObj);
@@ -146,16 +158,12 @@ public class AbstractSelectableChannelTest extends TestCase {
     /**
      * @tests AbstractSelectableChannel#register(Selector, int, Object)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "register",
-          methodArgs = {java.nio.channels.Selector.class, 
-                        int.class, java.lang.Object.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "register",
+        args = {java.nio.channels.Selector.class, int.class, java.lang.Object.class}
+    )
     public void test_register_LSelectorILObject() throws IOException {
         assertFalse(testChannel.isRegistered());
         Selector acceptSelector1 = SelectorProvider.provider().openSelector();
@@ -170,23 +178,19 @@ public class AbstractSelectableChannelTest extends TestCase {
         assertSame(sc, acceptKey.channel());
 
         //test that sc.register invokes Selector.register()
-        acceptKey = sc.register(acceptSelector2, SelectionKey.OP_READ, null);
-        assertNull(acceptKey);
+        sc.register(acceptSelector2, SelectionKey.OP_READ, null);
+        assertTrue(((MockAbstractSelector)acceptSelector2).isRegisterCalled);
     }
 
     /**
      * @tests AbstractSelectableChannel#register(Selector, int, Object)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "register",
-          methodArgs = {java.nio.channels.Selector.class, 
-                        int.class, java.lang.Object.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "register",
+        args = {java.nio.channels.Selector.class, int.class, java.lang.Object.class}
+    )
     public void test_register_LSelectorILObject_IllegalArgument()
             throws IOException {
         Selector acceptSelector = SelectorProvider.provider().openSelector();
@@ -279,20 +283,29 @@ public class AbstractSelectableChannelTest extends TestCase {
             // expected
         }
 
+        SelectorProvider prov1 = MockSelectorProvider.provider();
+        SelectorProvider prov2 = MockSelectorProvider.provider();
+        
+        Selector sel = prov2.openSelector();
+        
+        sc = prov1.openSocketChannel();
+        sc.configureBlocking(false);
+        try {
+            sc.register(sel, SelectionKey.OP_READ, null);
+        } catch (IllegalSelectorException e) {
+            // expected
+        }
     }
 
     /**
      * @tests AbstractSelectableChannel#keyFor(Selector)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "keyFor",
-          methodArgs = {java.nio.channels.Selector.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "keyFor",
+        args = {java.nio.channels.Selector.class}
+    )
     public void test_keyfor_LSelector() throws Exception {
         SocketChannel sc = SocketChannel.open();
         Object argObj = new Object();
@@ -315,15 +328,12 @@ public class AbstractSelectableChannelTest extends TestCase {
     /**
      * @tests AbstractSelectableChannel#configureBlocking(boolean)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "configureBlocking",
-          methodArgs = {boolean.class}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "configureBlocking",
+        args = {boolean.class}
+    )
     public void test_configureBlocking_Z_IllegalBlockingMode() throws Exception {
         SocketChannel sc = SocketChannel.open();
         sc.configureBlocking(false);
@@ -344,24 +354,49 @@ public class AbstractSelectableChannelTest extends TestCase {
     /**
      * @tests AbstractSelectableChannel#configureBlocking(boolean)
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "configureBlocking",
-          methodArgs = {boolean.class}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "configureBlocking",
+            args = {boolean.class}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "implConfigureBlocking",
+            args = {boolean.class}
         )
-    })
+    })   
     public void test_configureBlocking_Z() throws Exception {
-        MockSelectableChannel mock = new MockSelectableChannel(SelectorProvider
+        testChannel = new MockSelectableChannel(SelectorProvider
                 .provider());
-        //default blocking mode is true
-        //the implConfigureBlocking is only invoked if the given mode is different with current one
-        mock.configureBlocking(true);
-        assertFalse(mock.implConfigureBlockingCalled);
-        mock.configureBlocking(false);
-        assertTrue(mock.implConfigureBlockingCalled);
+        // default blocking mode is true. The implConfigureBlocking is only
+        // invoked if the given mode is different with current one.
+        testChannel.configureBlocking(true);
+        assertFalse(testChannel.implConfigureBlockingCalled);
+        testChannel.configureBlocking(false);
+        assertTrue(testChannel.implConfigureBlockingCalled);
+        
+        AbstractSelectableChannel channel = 
+                SelectorProvider.provider().openDatagramChannel();
+        channel.configureBlocking(false);
+        channel.register(SelectorProvider.provider().openSelector(),
+                SelectionKey.OP_READ);
+        try {
+            channel.configureBlocking(true);
+            fail("Should have thrown IllegalBlockingModeException");
+        } catch (IllegalBlockingModeException e) {
+            // expected
+        }
+        
+        testChannel.close();
+        try {
+            testChannel.configureBlocking(false);
+            fail("Should have thrown ClosedChannelException");
+        } catch (ClosedChannelException e) {
+            // expected
+        }
     }
 
     private class MockSelectableChannel extends AbstractSelectableChannel {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectionKeyTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectionKeyTest.java
index 9eca42e..33c3b5c 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectionKeyTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectionKeyTest.java
@@ -16,9 +16,10 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.nio.channels.SelectableChannel;
@@ -27,21 +28,28 @@ import java.nio.channels.Selector;
 import java.nio.channels.spi.AbstractSelectionKey;
 
 import junit.framework.TestCase;
-@TestTargetClass(AbstractSelectionKey.class)
+@TestTargetClass(
+    value = AbstractSelectionKey.class, 
+    untestedMethods = {
+        @TestTargetNew(
+            level = TestLevel.NOT_NECESSARY,
+            notes = "empty protected constructor",
+            method = "AbstractSelectionKey",
+            args = {}
+        )
+    }
+)
 public class AbstractSelectionKeyTest extends TestCase {
 
     /**
      * @tests AbstractSelectionKey#isValid() without selector
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isValid",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isValid",
+        args = {}
+    )
     public void test_isValid() throws Exception {
         MockSelectionKey testKey = new MockSelectionKey();
         assertTrue(testKey.isValid());
@@ -50,15 +58,12 @@ public class AbstractSelectionKeyTest extends TestCase {
     /**
      * @tests AbstractSelectionKey#cancel
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "cancel",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "cancel",
+        args = {}
+    )
     public void test_cancel() throws Exception {
         MockSelectionKey testKey = new MockSelectionKey();
         try {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectorTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectorTest.java
index 8ad2432..106184e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectorTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AbstractSelectorTest.java
@@ -16,18 +16,23 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.io.IOException;
-import java.nio.channels.IllegalBlockingModeException;
+import java.nio.channels.DatagramChannel;
+import java.nio.channels.Pipe;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.ServerSocketChannel;
+import java.nio.channels.SocketChannel;
+import java.nio.channels.spi.AbstractSelectableChannel;
+import java.nio.channels.spi.AbstractSelectionKey;
 import java.nio.channels.spi.SelectorProvider;
 import java.nio.channels.spi.AbstractSelector;
+import java.util.Set;
 
 import junit.framework.TestCase;
 @TestTargetClass(AbstractSelector.class)
@@ -39,13 +44,18 @@ public class AbstractSelectorTest extends TestCase {
     /**
      * @tests AbstractSelector#provider()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "provider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "AbstractSelector",
+            args = {SelectorProvider.class}
         )
     })
     public void test_provider() throws IOException {
@@ -60,13 +70,18 @@ public class AbstractSelectorTest extends TestCase {
     /**
      * @tests AbstractSelector#close()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "close",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "close",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "implCloseSelector",
+            args = {}
         )
     })
     public void test_close() throws IOException {
@@ -80,18 +95,19 @@ public class AbstractSelectorTest extends TestCase {
      * 
      * @tests AbstractSelector#begin/end()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "begin",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "begin",
+            args = {}
         ),
-        @TestTarget(
-          methodName = "end",
-          methodArgs = {}
-        )        
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "end",
+            args = {}
+        )
     })
     public void test_begin_end() throws IOException {
         MockAbstractSelector mockSelector = new MockAbstractSelector(
@@ -137,15 +153,12 @@ public class AbstractSelectorTest extends TestCase {
     /**
      * @tests AbstractSelector#isOpen()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "isOpen",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "isOpen",
+        args = {}
+    )
     public void test_isOpen() throws Exception {
         Selector acceptSelector = SelectorProvider.provider().openSelector();
         assertTrue(acceptSelector.isOpen());
@@ -154,73 +167,115 @@ public class AbstractSelectorTest extends TestCase {
     }
     
     /**
-     * @tests AbstractSelector#register(Selector,int)
+     * @tests AbstractSelector()
      */
-    @TestInfo(
-            level = TestLevel.TODO,
-            purpose = "Verifies register method from SelectableChannel " +
-                    "class.",
-            targets = {
-              @TestTarget(
-                methodName = "register",
-                methodArgs = {Selector.class, int.class}
-              )
-     })   
-    public void test_register_LSelectorI() throws Exception {
-        Selector acceptSelector = SelectorProvider.provider().openSelector();
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "AbstractSelector",
+        args = {SelectorProvider.class}
+    )
+    public void test_Constructor_LSelectorProvider() throws Exception {
+        Selector acceptSelector = new MockAbstractSelector(
+                SelectorProvider.provider());
+        assertSame(SelectorProvider.provider(), acceptSelector.provider());
+    }
+    
+    /**
+     * @tests AbstractSelector#register(AbstractSelectableChannel,int,Object)
+     */
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "Verifies register method from SelectableChannel class.",
+        method = "register",
+        args = {AbstractSelectableChannel.class, int.class, java.lang.Object.class}
+    )   
+    public void test_register_LAbstractSelectableChannelIObject() 
+            throws Exception {
+        Selector acceptSelector = new MockSelectorProvider().openSelector();
         ServerSocketChannel ssc = ServerSocketChannel.open();
         ssc.configureBlocking(false);
 
         assertFalse(ssc.isRegistered());
-        SelectionKey acceptKey = ssc.register(acceptSelector,
-                SelectionKey.OP_ACCEPT);
+        ssc.register(acceptSelector, SelectionKey.OP_ACCEPT);
         assertTrue(ssc.isRegistered());
+        assertTrue(((MockAbstractSelector)acceptSelector).isRegisterCalled);
+    }
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "cancelledKeys",
+        args = {}
+    )    
+    public void test_cancelledKeys() throws Exception {
+        MockSelectorProvider prov = new MockSelectorProvider();
+        Selector acceptSelector = prov.openSelector();
+        SocketChannel sc = prov.openSocketChannel();
+        sc.configureBlocking(false);
+
+        SelectionKey acceptKey = sc.register(acceptSelector,
+                SelectionKey.OP_READ, null);
+        acceptKey.cancel();
+        Set<SelectionKey> cKeys = 
+                ((MockAbstractSelector)acceptSelector).getCancelledKeys();
+        assertTrue(cKeys.contains(acceptKey));
+    }
+
+    @TestTargetNew(
+        level = TestLevel.COMPLETE,
+        notes = "",
+        method = "deregister",
+        args = {AbstractSelectionKey.class}
+    )
+    public void test_deregister() throws Exception {
+        MockSelectorProvider prov = new MockSelectorProvider();
+        AbstractSelector acceptSelector = prov.openSelector();
+        SocketChannel sc = prov.openSocketChannel();
+        sc.configureBlocking(false);
+
+        SelectionKey acceptKey = sc.register(acceptSelector,
+                SelectionKey.OP_READ, null);
+        assertTrue(sc.isRegistered());
         assertNotNull(acceptKey);
-        assertTrue(acceptSelector.keys().contains(acceptKey));
+        ((MockAbstractSelector)acceptSelector).mockDeregister(
+                (MockAbstractSelector.MockSelectionKey)acceptKey);
+        assertFalse(sc.isRegistered());
     }
 
-    /**
-     * @tests AbstractSelector#register(Selector,int)
-     */
-    @TestInfo(
-            level = TestLevel.TODO,
-            purpose = "Verifies register method from SelectableChannel " +
-                    "class.",
-            targets = {
-              @TestTarget(
-                methodName = "register",
-                methodArgs = {Selector.class, int.class}
-              )
-     })    
-    public void test_register_LSelectorI_error() throws IOException {
-        Selector acceptSelector = SelectorProvider.provider().openSelector();
-        ServerSocketChannel ssc = ServerSocketChannel.open();
-        ssc.configureBlocking(false);
-        acceptSelector.close();
+    static class MockSelectorProvider extends SelectorProvider {
+        
+        private  MockSelectorProvider() {
+            // do nothing
+        }
 
-        assertFalse(acceptSelector.isOpen());
-        try {
-            ssc.register(acceptSelector, SelectionKey.OP_ACCEPT);
-            fail("should throw NullPointerException");
-        } catch (NullPointerException e) {
-            // expected
+        @Override
+        public DatagramChannel openDatagramChannel() {
+            return null;
         }
-        assertFalse(ssc.isRegistered());
 
-        acceptSelector = Selector.open();
-        ssc.configureBlocking(true);
-        try {
-            ssc.register(acceptSelector, SelectionKey.OP_ACCEPT);
-            fail("should throw IllegalBlockingModeException");
-        } catch (IllegalBlockingModeException e) {
-            // expected
+        @Override
+        public Pipe openPipe() {
+            return null;
         }
-        assertFalse(ssc.isRegistered());
-        ssc.configureBlocking(false);
-        SelectionKey acceptKey = ssc.register(acceptSelector,
-                SelectionKey.OP_ACCEPT);
-        assertNotNull(acceptKey);
-        assertTrue(acceptSelector.keys().contains(acceptKey));
-        assertTrue(ssc.isRegistered());
-    }    
+
+        @Override
+        public AbstractSelector openSelector() {
+            return new MockAbstractSelector(provider());
+        }
+
+        @Override
+        public ServerSocketChannel openServerSocketChannel() {
+            return null;
+        }
+
+        @Override
+        public SocketChannel openSocketChannel() throws IOException {
+            return SocketChannel.open();
+        }
+
+        public static SelectorProvider provider() {
+            return new MockSelectorProvider();
+        }
+    }
 }
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AllTests.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AllTests.java
index 4febb4b..1b5e12e 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AllTests.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/AllTests.java
@@ -22,7 +22,7 @@ import junit.framework.TestSuite;
 public class AllTests {
 
     public static Test suite() {
-        TestSuite suite = new TestSuite(
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite(
                 "Test for tests.api.java.nio.channels.spi");
         //$JUnit-BEGIN$
         suite.addTestSuite(AbstractInterruptibleChannelTest.class);
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/MockAbstractSelector.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/MockAbstractSelector.java
index eb6e53f..a48f2a9 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/MockAbstractSelector.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/MockAbstractSelector.java
@@ -17,17 +17,58 @@
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
 import java.io.IOException;
+import java.nio.channels.SelectableChannel;
 import java.nio.channels.SelectionKey;
 import java.nio.channels.Selector;
 import java.nio.channels.spi.AbstractSelectableChannel;
 import java.nio.channels.spi.AbstractSelectionKey;
 import java.nio.channels.spi.AbstractSelector;
 import java.nio.channels.spi.SelectorProvider;
+import java.util.HashSet;
 import java.util.Set;
 
 public class MockAbstractSelector extends AbstractSelector {
+    
+    class MockSelectionKey extends AbstractSelectionKey {
+
+        boolean cancelled = false;
+        Selector selector;
+        SelectableChannel channel;
+        
+        MockSelectionKey(Selector sel, SelectableChannel chan) {
+            selector = sel;
+            channel = chan;
+        }
+
+        @Override
+        public SelectableChannel channel() {
+            return channel;
+        }
+
+        @Override
+        public int interestOps() {
+            return 0;
+        }
+
+        @Override
+        public SelectionKey interestOps(int operations) {
+            return null;
+        }
+
+        @Override
+        public int readyOps() {
+            return 0;
+        }
+
+        @Override
+        public Selector selector() {
+            return selector;
+        }
+    }
 
     public boolean isImplCloseSelectorCalled = false;
+    private Set<SelectionKey> keys = new HashSet<SelectionKey>();
+    public boolean isRegisterCalled = false;
     
     public MockAbstractSelector(SelectorProvider arg0) {
         super(arg0);
@@ -37,7 +78,7 @@ public class MockAbstractSelector extends AbstractSelector {
         return new MockAbstractSelector(SelectorProvider.provider());
     }
 
-    public Set getCancelledKeys() {
+    public Set<SelectionKey> getCancelledKeys() {
         return super.cancelledKeys();
     }
 
@@ -47,7 +88,11 @@ public class MockAbstractSelector extends AbstractSelector {
 
     protected SelectionKey register(AbstractSelectableChannel arg0, int arg1,
             Object arg2) {
-        return null;
+        isRegisterCalled = true;
+        
+        SelectionKey key = new MockSelectionKey(this, arg0);
+        keys.add(key);
+        return key;
     }
 
     public void superBegin() {
@@ -58,12 +103,12 @@ public class MockAbstractSelector extends AbstractSelector {
         super.end();
     }
 
-    protected void mockDeregister(AbstractSelectionKey key) {
+    public void mockDeregister(AbstractSelectionKey key) {
         super.deregister(key);
     }
 
     public Set<SelectionKey> keys() {
-        return null;
+        return keys;
     }
 
     public Set<SelectionKey> selectedKeys() {
diff --git a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/SelectorProviderTest.java b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/SelectorProviderTest.java
index 27fffdf..f18d585 100644
--- a/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/SelectorProviderTest.java
+++ b/nio/src/test/java/org/apache/harmony/nio/tests/java/nio/channels/spi/SelectorProviderTest.java
@@ -16,9 +16,9 @@
 
 package org.apache.harmony.nio.tests.java.nio.channels.spi;
 
-import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestTargets;
 import dalvik.annotation.TestLevel;
-import dalvik.annotation.TestTarget;
+import dalvik.annotation.TestTargetNew;
 import dalvik.annotation.TestTargetClass;
 
 import java.io.IOException;
@@ -35,17 +35,85 @@ import junit.framework.TestCase;
 public class SelectorProviderTest extends TestCase {
 
     /**
-     * @tests SelectorProvider#provider() using security manager
+     * @tests SelectorProvider#openDatagramChannel()
+     * @tests SelectorProvider#openPipe()
+     * @tests SelectorProvider#openServerSocketChannel()
+     * @tests SelectorProvider#openSocketChannel()
+     * @tests SelectorProvider#openSelector()
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
+    @TestTargets({
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "SelectorProvider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "provider",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "inheritedChannel",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "openDatagramChannel",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "openPipe",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "openServerSocketChannel",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.PARTIAL_COMPLETE,
+            notes = "",
+            method = "openSocketChannel",
+            args = {}
+        ),
+        @TestTargetNew(
+            level = TestLevel.COMPLETE,
+            notes = "",
+            method = "openSelector",
+            args = {}
         )
     })
+    public void test_open_methods() throws Exception {
+        // calling #provider to see if it returns without Exception.
+        assertNotNull(SelectorProvider.provider());
+
+        // calling #inheritedChannel to see if this already throws an exception.
+        SelectorProvider.provider().inheritedChannel();
+
+        assertNotNull(SelectorProvider.provider().openDatagramChannel());
+        assertNotNull(SelectorProvider.provider().openPipe());
+        assertNotNull(SelectorProvider.provider().openServerSocketChannel());
+        assertNotNull(SelectorProvider.provider().openSocketChannel());
+        assertNotNull(SelectorProvider.provider().openSelector());
+    }
+
+    /**
+     * @tests SelectorProvider#provider() using security manager
+     */
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "provider",
+        args = {}
+    )
     public void test_provider_security() {        
         SecurityManager originalSecuirtyManager = System.getSecurityManager();
         System.setSecurityManager(new MockSelectorProviderSecurityManager());
@@ -62,15 +130,12 @@ public class SelectorProviderTest extends TestCase {
     /**
      * @tests SelectorProvider#provider() using security manager
      */
-    @TestInfo(
-      level = TestLevel.COMPLETE,
-      purpose = "",
-      targets = {
-        @TestTarget(
-          methodName = "provider",
-          methodArgs = {}
-        )
-    })
+    @TestTargetNew(
+        level = TestLevel.PARTIAL_COMPLETE,
+        notes = "",
+        method = "provider",
+        args = {}
+    )
     public void test_provider_security_twice() {
         SelectorProvider.provider();
         SecurityManager originalSecuirtyManager = System.getSecurityManager();
diff --git a/nio/src/test/java/tests/nio/AllTests.java b/nio/src/test/java/tests/nio/AllTests.java
index 1abe67a..ff50aa5 100644
--- a/nio/src/test/java/tests/nio/AllTests.java
+++ b/nio/src/test/java/tests/nio/AllTests.java
@@ -29,7 +29,7 @@ public class AllTests {
     }
 
     public static Test suite() {
-        TestSuite suite = new TestSuite("All Math test suites");
+        TestSuite suite = tests.TestSuiteFactory.createTestSuite("All Math test suites");
         // $JUnit-BEGIN$
         suite.addTest(org.apache.harmony.nio.tests.java.nio.AllTests.suite());
         suite.addTest(org.apache.harmony.nio.tests.java.nio.channels.AllTests.suite());