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

15 files changed, 5585 insertions, 4037 deletions

diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/AbstractPreferencesTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/AbstractPreferencesTest.java
index 8f19666..9fbe80d 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/AbstractPreferencesTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/AbstractPreferencesTest.java
@@ -17,6 +17,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.File;
@@ -51,1831 +56,2569 @@ import org.xml.sax.SAXException;
  * TODO: refine this test to adapt all implementations
  * 
  */
+@TestTargetClass(AbstractPreferences.class)
 public class AbstractPreferencesTest extends TestCase {
 
-	AbstractPreferences pref;
-
-	static AbstractPreferences root = null;
-
-	static AbstractPreferences parent = null;
-
-	final static String longKey;
-
-	final static String longValue;
-
-	final static String longName;
-
-	MockNodeChangeListener nl;
-
-	MockPreferenceChangeListener pl;
-
-	static {
-		StringBuffer key = new StringBuffer(Preferences.MAX_KEY_LENGTH);
-		for (int i = 0; i < Preferences.MAX_KEY_LENGTH; i++) {
-			key.append('a');
-		}
-		longKey = key.toString();
-		StringBuffer value = new StringBuffer(Preferences.MAX_VALUE_LENGTH);
-		for (int i = 0; i < Preferences.MAX_VALUE_LENGTH; i++) {
-			value.append('a');
-		}
-		longValue = value.toString();
-
-		StringBuffer name = new StringBuffer(Preferences.MAX_NAME_LENGTH);
-		for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) {
-			name.append('a');
-		}
-		longName = name.toString();
-	}
-
-	protected void setUp() throws Exception {
-		super.setUp();
-		root = (AbstractPreferences) Preferences.userRoot();
-		parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-		// FIXME: change here is dangerous
-		// pref = new MockAbstractPreferences((AbstractPreferences) parent,
-		// "mock");
-
-		pref = (AbstractPreferences) parent.node("mock");
-	}
-
-	protected void tearDown() throws Exception {
-		try {
-			if (pref instanceof MockAbstractPreferences) {
-				((MockAbstractPreferences) pref)
-						.setResult(MockAbstractPreferences.NORMAL);
-			}
-			pref.removeNode();
-		} catch (Exception e) {
-		}
-		super.tearDown();
-	}
-
-	public void testConstructor() throws BackingStoreException {
-		try {
-			pref = new MockAbstractPreferences(
-					(AbstractPreferences) Preferences.userRoot(), "mo/ck");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref = new MockAbstractPreferences(null, "mock");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			new MockAbstractPreferences(null, " ");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			new MockAbstractPreferences(pref, "");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			new MockAbstractPreferences(pref, null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		new MockAbstractPreferences(pref, " ");
-
-		Preferences p2 = new MockAbstractPreferences(null, "");
-		assertNotSame(p2, Preferences.systemRoot());
-		assertNotSame(p2, Preferences.userRoot());
-		assertFalse(p2.isUserNode());
-
-		p2 = new MockAbstractPreferences((AbstractPreferences) Preferences
-				.userRoot(), "mock");
-		assertNotSame(p2, pref);
-		p2.removeNode();
-	}
-
-	public void testProtectedFields() throws BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = new MockAbstractPreferences(pref, "newNode");
-		assertFalse(p.getNewNode());
-		assertSame(p.getLock().getClass(), Object.class);
-
-		p = (MockAbstractPreferences) pref.node("child");
-		assertTrue(p.getNewNode());
-
-		p = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
-				.publicChildSpi("child2");
-		assertTrue(p.getNewNode());
-	}
-
-	public void testToString() {
-		assertEquals("User Preference Node: " + pref.absolutePath(), pref
-				.toString());
-
-		pref = new MockAbstractPreferences((AbstractPreferences) Preferences
-				.systemRoot(), "mock");
-		assertEquals("System Preference Node: " + pref.absolutePath(), pref
-				.toString());
-	}
-
-	public void testAbsolutePath() {
-		assertEquals("/java/util/prefs/mock", pref.absolutePath());
-
-		pref = new MockAbstractPreferences(pref, " ");
-		assertEquals("/java/util/prefs/mock/ ", pref.absolutePath());
-	}
-
-	public void testChildrenNames() throws BackingStoreException {
-		assertEquals(0, pref.childrenNames().length);
-
-		Preferences child1 = pref.node("child1");
-
-		pref.node("child2");
-		pref.node("child3");
-		child1.node("subchild1");
-
-		assertSame(pref, child1.parent());
-		assertEquals(3, pref.childrenNames().length);
-		assertEquals("child1", pref.childrenNames()[0]);
-		assertEquals(1, child1.childrenNames().length);
-		assertEquals("subchild1", child1.childrenNames()[0]);
-	}
-
-	public void testClear() throws BackingStoreException {
-		pref.put("testClearKey", "testClearValue");
-		pref.put("testClearKey1", "testClearValue1");
-		assertEquals("testClearValue", pref.get("testClearKey", null));
-		assertEquals("testClearValue1", pref.get("testClearKey1", null));
-		pref.clear();
-		assertNull(pref.get("testClearKey", null));
-		assertNull(pref.get("testClearKey1", null));
-	}
-
-	public void testGet() throws BackingStoreException {
-		assertNull(pref.get("", null));
-		assertEquals("default", pref.get("key", "default"));
-		assertNull(pref.get("key", null));
-		pref.put("testGetkey", "value");
-		assertNull(pref.get("testGetKey", null));
-		assertEquals("value", pref.get("testGetkey", null));
-
-		try {
-			pref.get(null, "abc");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.get("", "abc");
-		pref.get("key", null);
-		pref.get("key", "");
-		pref.putFloat("floatKey", 1.0f);
-		assertEquals("1.0", pref.get("floatKey", null));
-
-		pref.removeNode();
-		try {
-			pref.get("key", "abc");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.get(null, "abc");
-			fail();
-		} catch (NullPointerException e) {
-		}
-	}
-
-	public void testGetBoolean() {
-		try {
-			pref.getBoolean(null, false);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetBooleanKey", "false");
-		pref.put("testGetBooleanKey2", "value");
-		assertFalse(pref.getBoolean("testGetBooleanKey", true));
-		assertTrue(pref.getBoolean("testGetBooleanKey2", true));
-	}
-
-	public void testPutByteArray() {
-		try {
-			pref.putByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.putByteArray("testPutByteArrayKey4", null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.putByteArray(longKey, new byte[0]);
-		try {
-			pref.putByteArray(longKey + "a", new byte[0]);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		byte[] longArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.74)];
-		byte[] longerArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.75) + 1];
-		pref.putByteArray(longKey, longArray);
-		try {
-			pref.putByteArray(longKey, longerArray);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		pref.putByteArray("testPutByteArrayKey", new byte[0]);
-		assertEquals("", pref.get("testPutByteArrayKey", null));
-		assertTrue(Arrays.equals(new byte[0], pref.getByteArray(
-				"testPutByteArrayKey", null)));
-
-		pref.putByteArray("testPutByteArrayKey3", new byte[] { 'a', 'b', 'c' });
-		assertEquals("YWJj", pref.get("testPutByteArrayKey3", null));
-		assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
-				.getByteArray("testPutByteArrayKey3", null)));
-	}
-
-	public void testGetByteArray() throws UnsupportedEncodingException {
-		try {
-			pref.getByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		byte[] b64Array = new byte[] { 0x59, 0x57, 0x4a, 0x6a };// BASE64
-		// encoding for
-		// "abc"
-
-		pref.put("testGetByteArrayKey", "abc=");
-		pref.put("testGetByteArrayKey2", new String(b64Array));
-		pref.put("invalidKey", "<>?");
-		// assertTrue(Arrays.equals(new byte[0], p.getByteArray(
-		// "testGetByteArrayKey", new byte[0])));
-		assertTrue(Arrays.equals(new byte[] { 105, -73 }, pref.getByteArray(
-				"testGetByteArrayKey", new byte[0])));
-		assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
-				.getByteArray("testGetByteArrayKey2", new byte[0])));
-		assertTrue(Arrays.equals(new byte[0], pref.getByteArray("invalidKey",
-				new byte[0])));
-
-		pref.putByteArray("testGetByteArrayKey3", b64Array);
-		pref.putByteArray("testGetByteArrayKey4", "abc".getBytes());
-		assertTrue(Arrays.equals(b64Array, pref.getByteArray(
-				"testGetByteArrayKey3", new byte[0])));
-		assertTrue(Arrays.equals("abc".getBytes(), pref.getByteArray(
-				"testGetByteArrayKey4", new byte[0])));
-	}
-
-	public void testGetDouble() {
-		try {
-			pref.getDouble(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetDoubleKey", "1");
-		pref.put("testGetDoubleKey2", "value");
-		pref.putDouble("testGetDoubleKey3", 1);
-		pref.putInt("testGetDoubleKey4", 1);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey", 0.0), 0);
-		assertEquals(0.0, pref.getDouble("testGetDoubleKey2", 0.0), 0);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey3", 0.0), 0);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey4", 0.0), 0);
-	}
-
-	public void testGetFloat() {
-		try {
-			pref.getFloat(null, 0f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.put("testGetFloatKey", "1");
-		pref.put("testGetFloatKey2", "value");
-		assertEquals(1f, pref.getFloat("testGetFloatKey", 0f), 0); //$NON-NLS-1$
-		assertEquals(0f, pref.getFloat("testGetFloatKey2", 0f), 0);
-	}
-
-	public void testGetInt() {
-		try {
-			pref.getInt(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetIntKey", "1");
-		pref.put("testGetIntKey2", "value");
-		assertEquals(1, pref.getInt("testGetIntKey", 0));
-		assertEquals(0, pref.getInt("testGetIntKey2", 0));
-	}
-
-	public void testGetLong() {
-		try {
-			pref.getLong(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetLongKey", "1");
-		pref.put("testGetLongKey2", "value");
-		assertEquals(1, pref.getInt("testGetLongKey", 0));
-		assertEquals(0, pref.getInt("testGetLongKey2", 0));
-	}
-
-	public void testIsUserNode() {
-		assertTrue(pref.isUserNode());
-
-		pref = new MockAbstractPreferences((AbstractPreferences) Preferences
-				.systemRoot(), "mock");
-		assertFalse(pref.isUserNode());
-	}
-
-	// TODO, how to test the "stored defaults"
-	// TODO, how to test the multi-thread
-	public void testKeys() throws BackingStoreException {
-		assertEquals(0, pref.keys().length);
-
-		pref.put("key0", "value");
-		pref.put("key1", "value1");
-		pref.put("key2", "value2");
-		pref.put("key3", "value3");
-
-		String[] keys = pref.keys();
-		assertEquals(4, keys.length);
-		for (int i = 0; i < keys.length; i++) {
-			assertEquals(0, keys[i].indexOf("key"));
-			assertEquals(4, keys[i].length());
-		}
-	}
-
-	public void testName() {
-		assertEquals("mock", pref.name());
-
-		pref = new MockAbstractPreferences(pref, " ");
-		assertEquals(" ", pref.name());
-	}
-
-	public void testCharCase() throws BackingStoreException {
-		assertSame(pref.node("samechild"), pref.node("samechild"));
-		assertNotSame(pref.node("sameChild"), pref.node("samechild"));
-		assertNotSame(pref.node("child"), pref.node("Child"));
-		assertNotSame(pref.node("child"), pref.node("Child"));
-		assertNotSame(pref.node("child"), pref.node(" child"));
-		String[] names = pref.childrenNames();
-		assertEquals(5, names.length);
-		for (int i = 0; i < names.length; i++) {
-			String name = names[i];
-			assertTrue("samechild".equals(name) || "sameChild".equals(name)
-					|| "child".equals(name) || "Child".equals(name)
-					|| " child".equals(name));
-		}
-
-		Preferences mock1 = pref.node("mock1");
-		mock1.put("key", "1value");
-		mock1.put("KEY", "2value");
-		mock1.put("/K/E/Y", "7value");
-		mock1.put("/K/E\\Y\\abc~@!#$%^&*(\\", "8value");
-
-		assertEquals("8value", mock1.get("/K/E\\Y\\abc~@!#$%^&*(\\", null));
-		assertNull(mock1.get("/k/e/y", null));
-		assertEquals("7value", mock1.get("/K/E/Y", null));
-		assertEquals("1value", mock1.get("key", null));
-
-		String[] keys = mock1.keys();
-		assertEquals(4, keys.length);
-		for (int i = 0; i < keys.length; i++) {
-			String key = keys[i];
-			assertTrue("key".equals(key) || "KEY".equals(key)
-					|| "/K/E/Y".equals(key)
-					|| "/K/E\\Y\\abc~@!#$%^&*(\\".equals(key));
-		}
-	}
-
-	public void testNode() throws BackingStoreException {
-		try {
-			pref.node(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.node("/java/util/prefs/");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.node("/java//util/prefs");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.node(longName + "a");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		assertNotNull(pref.node(longName));
-
-		assertSame(root, pref.node("/"));
-
-		Preferences prefs = pref.node("/java/util/prefs");
-		assertSame(prefs, parent);
-
-		assertSame(pref, pref.node(""));
-
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences child = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
-				.publicChildSpi("child");
-		assertSame(child, pref.node("child"));
-
-		Preferences child2 = pref.node("child2");
-		assertSame(child2, ((MockAbstractPreferences) pref)
-				.publicChildSpi("child2"));
-
-		Preferences grandchild = pref.node("child/grandchild");
-		assertSame(grandchild, child.childSpi("grandchild"));
-		assertSame(grandchild, child.cachedChildrenImpl()[0]);
-		grandchild.removeNode();
-		assertNotSame(grandchild, pref.node("child/grandchild"));
-
-		grandchild = pref.node("child3/grandchild");
-		AbstractPreferences[] childs = ((MockAbstractPreferences) pref)
-				.cachedChildrenImpl();
-		Preferences child3 = child;
-		for (int i = 0; i < childs.length; i++) {
-			if (childs[i].name().equals("child3")) {
-				child3 = childs[i];
-				break;
-			}
-		}
-		assertSame(child3, grandchild.parent());
-	}
-
-	public void testNodeExists() throws BackingStoreException {
-		try {
-			pref.nodeExists(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.nodeExists("/java/util/prefs/");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.nodeExists("/java//util/prefs");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		assertTrue(pref.nodeExists("/"));
-
-		assertTrue(pref.nodeExists("/java/util/prefs"));
-
-		assertTrue(pref.nodeExists(""));
-
-		assertFalse(pref.nodeExists("child"));
-		Preferences grandchild = pref.node("child/grandchild");
-		assertTrue(pref.nodeExists("child"));
-		assertTrue(pref.nodeExists("child/grandchild"));
-		grandchild.removeNode();
-		assertTrue(pref.nodeExists("child"));
-		assertFalse(pref.nodeExists("child/grandchild"));
-		assertFalse(grandchild.nodeExists(""));
-
-		assertFalse(pref.nodeExists("child2/grandchild"));
-		pref.node("child2/grandchild");
-		assertTrue(pref.nodeExists("child2/grandchild"));
-	}
-
-	public void testParent() {
-		assertSame(parent, pref.parent());
-		AbstractPreferences child1 = new MockAbstractPreferences(pref, "child1");
-		assertSame(pref, child1.parent());
-		assertNull(root.parent());
-	}
-
-	public void testPut() throws BackingStoreException {
-		pref.put("", "emptyvalue");
-		assertEquals("emptyvalue", pref.get("", null));
-		pref.put("testPutkey", "value1");
-		assertEquals("value1", pref.get("testPutkey", null));
-		pref.put("testPutkey", "value2");
-		assertEquals("value2", pref.get("testPutkey", null));
-
-		pref.put("", "emptyvalue");
-		assertEquals("emptyvalue", pref.get("", null));
-
-		try {
-			pref.put(null, "value");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.put("key", null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.put(longKey, longValue);
-		try {
-			pref.put(longKey + 1, longValue);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.put(longKey, longValue + 1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		pref.removeNode();
-		try {
-			pref.put(longKey, longValue + 1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		try {
-			pref.put(longKey, longValue);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
-
-	public void testPutBoolean() {
-		try {
-			pref.putBoolean(null, false);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putBoolean(longKey, false);
-		try {
-			pref.putBoolean(longKey + "a", false);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putBoolean("testPutBooleanKey", false);
-		assertEquals("false", pref.get("testPutBooleanKey", null));
-		assertFalse(pref.getBoolean("testPutBooleanKey", true));
-	}
-
-	public void testPutDouble() {
-		try {
-			pref.putDouble(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putDouble(longKey, 3);
-		try {
-			pref.putDouble(longKey + "a", 3);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putDouble("testPutDoubleKey", 3);
-		assertEquals("3.0", pref.get("testPutDoubleKey", null));
-		assertEquals(3, pref.getDouble("testPutDoubleKey", 0), 0);
-	}
-
-	public void testPutFloat() {
-		try {
-			pref.putFloat(null, 3f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putFloat(longKey, 3f);
-		try {
-			pref.putFloat(longKey + "a", 3f);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putFloat("testPutFloatKey", 3f);
-		assertEquals("3.0", pref.get("testPutFloatKey", null));
-		assertEquals(3f, pref.getFloat("testPutFloatKey", 0), 0);
-	}
-
-	public void testPutInt() {
-		try {
-			pref.putInt(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putInt(longKey, 3);
-		try {
-			pref.putInt(longKey + "a", 3);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putInt("testPutIntKey", 3);
-		assertEquals("3", pref.get("testPutIntKey", null));
-		assertEquals(3, pref.getInt("testPutIntKey", 0));
-	}
-
-	public void testPutLong() {
-		try {
-			pref.putLong(null, 3L);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putLong(longKey, 3L);
-		try {
-			pref.putLong(longKey + "a", 3L);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putLong("testPutLongKey", 3L);
-		assertEquals("3", pref.get("testPutLongKey", null));
-		assertEquals(3L, pref.getLong("testPutLongKey", 0));
-	}
-
-	public void testRemove() throws BackingStoreException {
-		pref.remove("key");
-
-		pref.put("key", "value");
-		assertEquals("value", pref.get("key", null));
-		pref.remove("key");
-		assertNull(pref.get("key", null));
-
-		pref.remove("key");
-
-		try {
-			pref.remove(null);
-		} catch (NullPointerException e) {
-		}
-
-		pref.removeNode();
-		try {
-			pref.remove("key");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
-
-	public void testRemoveNode() throws BackingStoreException {
-		Preferences child = pref.node("child");
-		Preferences child1 = pref.node("child1");
-		Preferences grandchild = child.node("grandchild");
-
-		pref.removeNode();
-
-		assertFalse(child.nodeExists(""));
-		assertFalse(child1.nodeExists(""));
-		assertFalse(grandchild.nodeExists(""));
-		assertFalse(pref.nodeExists(""));
-	}
-
-	public void testAddNodeChangeListener() throws BackingStoreException {
-		try {
-			pref.addNodeChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		Preferences child1 = null;
-		Preferences child2 = null;
-		Preferences child3 = null;
-		// To get existed node doesn't create the change event
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock1");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-			child2 = pref.node("mock1");
-			assertEquals(0, nl.getAdded());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			child1.removeNode();
-		}
-		// same listener can be added twice, and must be removed twice
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock2");
-			assertEquals(2, nl.getAdded());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			pref.removeNodeChangeListener(nl);
-			child1.removeNode();
-		}
-		// test remove event
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock3");
-			child1.removeNode();
-			assertEquals(1, nl.getRemoved());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-		}
-		// test remove event with two listeners
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock6");
-			child1.removeNode();
-			assertEquals(2, nl.getRemoved());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			pref.removeNodeChangeListener(nl);
-		}
-		// test add/remove indirect children, or remove several children at the
-		// same time
-		try {
-			nl = new MockNodeChangeListener();
-			child1 = pref.node("mock4");
-			child1.addNodeChangeListener(nl);
-			child2 = pref.node("mock4/mock5");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-			child3 = pref.node("mock4/mock5/mock6");
-			assertEquals(0, nl.getAdded());
-			nl.reset();
-
-			child3.removeNode();
-			assertEquals(0, nl.getRemoved());
-			nl.reset();
-
-			child3 = pref.node("mock4/mock7");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-
-			child1.removeNode();
-			assertEquals(2, nl.getRemoved());
-			nl.reset();
-		} finally {
-			try {
-				child1.removeNode();
-			} catch (Exception e) {
-			}
-		}
-
-	}
-
-	public void testAddPreferenceChangeListener() {
-		// TODO: start from here
-		try {
-			pref.addPreferenceChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		// To get existed node doesn't create the change event
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.putInt("mock1", 123);
-			assertEquals(1, pl.getChanged());
-			pref.putLong("long_key", Long.MAX_VALUE);
-			assertEquals(2, pl.getChanged());
-			pl.reset();
-
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-			//child1.removeNode();
-		}
-				      
-		// same listener can be added twice, and must be removed twice
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.addPreferenceChangeListener(pl);
-			pref.putFloat("float_key", Float.MIN_VALUE);
-			assertEquals(2, pl.getChanged());
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-			pref.removePreferenceChangeListener(pl);
-
-		}
-	}
-
-	public void testRemoveNodeChangeListener() {
-		try {
-			pref.removeNodeChangeListener(null);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		MockNodeChangeListener l1 = new MockNodeChangeListener();
-		MockNodeChangeListener l2 = new MockNodeChangeListener();
-		pref.addNodeChangeListener(l1);
-		pref.addNodeChangeListener(l1);
-
-		pref.removeNodeChangeListener(l1);
-		pref.removeNodeChangeListener(l1);
-		try {
-			pref.removeNodeChangeListener(l1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.removeNodeChangeListener(l2);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-	}
-
-	public void testRemovePreferenceChangeListener() {
-		try {
-			pref.removePreferenceChangeListener(null);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		MockPreferenceChangeListener l1 = new MockPreferenceChangeListener();
-		MockPreferenceChangeListener l2 = new MockPreferenceChangeListener();
-		pref.addPreferenceChangeListener(l1);
-		pref.addPreferenceChangeListener(l1);
-		try {
-			pref.removePreferenceChangeListener(l2);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.removePreferenceChangeListener(l1);
-		pref.removePreferenceChangeListener(l1);
-		try {
-			pref.removePreferenceChangeListener(l1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-	}
-
-	public void testSync() throws BackingStoreException {
-
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.resetSyncTimes();
-		p.sync();
-		assertEquals(1, p.getSyncTimes());
-
-		p.resetSyncTimes();
-		MockAbstractPreferences child = (MockAbstractPreferences) p
-				.node("child");
-		MockAbstractPreferences child2 = new MockAbstractPreferences(p,
-				"child2");
-		p.childs.put("child2", child2);
-		assertEquals(1, p.cachedChildrenImpl().length);
-		assertSame(child, p.cachedChildrenImpl()[0]);
-		p.sync();
-		assertEquals(1, p.getSyncTimes());
-		assertEquals(1, child.getSyncTimes());
-		assertEquals(0, child2.getSyncTimes());
-
-		p.resetSyncTimes();
-		child.resetSyncTimes();
-		child.sync();
-		assertEquals(0, p.getSyncTimes());
-		assertEquals(1, child.getSyncTimes());
-
-		p.resetSyncTimes();
-		child.resetSyncTimes();
-		MockAbstractPreferences grandson = (MockAbstractPreferences) child
-				.node("grandson");
-		child.sync();
-		assertEquals(0, p.getSyncTimes());
-		assertEquals(1, child.getSyncTimes());
-		assertEquals(1, grandson.getSyncTimes());
-	}
-
-	public void testFlush() throws BackingStoreException {
-		
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.resetFlushedTimes();
-		p.flush();
-		assertEquals(1, p.getFlushedTimes());
-
-		p.resetFlushedTimes();
-		MockAbstractPreferences child = (MockAbstractPreferences) p
-				.node("child");
-		MockAbstractPreferences child2 = new MockAbstractPreferences(p,
-				"child2");
-		p.childs.put("child2", child2);
-		assertEquals(1, p.cachedChildrenImpl().length);
-		assertSame(child, p.cachedChildrenImpl()[0]);
-		p.flush();
-		assertEquals(1, p.getFlushedTimes());
-		assertEquals(1, child.getFlushedTimes());
-		assertEquals(0, child2.getFlushedTimes());
-
-		p.resetFlushedTimes();
-		child.resetFlushedTimes();
-		child.flush();
-		assertEquals(0, p.getFlushedTimes());
-		assertEquals(1, child.getFlushedTimes());
-
-		p.resetFlushedTimes();
-		child.resetFlushedTimes();
-		MockAbstractPreferences grandson = (MockAbstractPreferences) child
-				.node("grandson");
-		child.flush();
-		assertEquals(0, p.getFlushedTimes());
-		assertEquals(1, child.getFlushedTimes());
-		assertEquals(1, grandson.getFlushedTimes());
-
-		p.resetFlushedTimes();
-		child.resetFlushedTimes();
-		grandson.resetFlushedTimes();
-		child.removeNode();
-		child.flush();
-		assertEquals(0, p.getFlushedTimes());
-		assertEquals(1, child.getFlushedTimes());
-		assertEquals(0, grandson.getFlushedTimes());
-	}
-
-	public void testGetChild() throws BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		assertNull(p.getChildImpl("child"));
-		MockAbstractPreferences child = new MockAbstractPreferences(p, "child");
-		p.childs.put("child", child);
-		assertSame(child, p.getChildImpl("child"));
-		assertNull(p.getChildImpl("child "));
-
-		assertNull(p.getChildImpl("child/grandson"));
-		child.childs.put("grandson", new MockAbstractPreferences(child,
-				"grandson"));
-		assertNull(p.getChildImpl("child/grandson"));
-
-		assertNull(p.getChildImpl(null));
-		assertNull(p.getChildImpl(""));
-		assertNull(p.getChildImpl(" "));
-		assertNull(p.getChildImpl("abc//abc"));
-		assertNull(p.getChildImpl("child/"));
-		assertNull(p.getChildImpl(longName + "a"));
-
-		child.removeNode();
-		assertNull(p.getChildImpl("child"));
-	}
-
-	public void testIsRemoved() throws BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		assertFalse(p.isRemovedImpl());
-		p.removeNode();
-		assertTrue(p.isRemovedImpl());
-	}
-
-	public void testExportNode() throws Exception {
-		try {
-			pref.exportNode(null);
-			fail();
-		} catch (NullPointerException e) {
-			// Expected
-		}
-
-		pref.putBoolean("key", false);
-		Preferences child = pref.node("child<");
-		child.put("key2", "value2<");
-		Preferences grandson = child.node("grandson");
-		grandson.put("key3", "value3");
-		ByteArrayOutputStream out = new ByteArrayOutputStream();
-	    child.exportNode(out);
-
-		byte[] result = out.toString().getBytes();
-		ByteArrayInputStream in = new ByteArrayInputStream(result);
+    AbstractPreferences pref;
+
+    static AbstractPreferences root = null;
+
+    static AbstractPreferences parent = null;
+
+    final static String longKey;
+
+    final static String longValue;
+
+    final static String longName;
+
+    MockNodeChangeListener nl;
+
+    MockPreferenceChangeListener pl;
+
+    static {
+        StringBuffer key = new StringBuffer(Preferences.MAX_KEY_LENGTH);
+        for (int i = 0; i < Preferences.MAX_KEY_LENGTH; i++) {
+            key.append('a');
+        }
+        longKey = key.toString();
+        StringBuffer value = new StringBuffer(Preferences.MAX_VALUE_LENGTH);
+        for (int i = 0; i < Preferences.MAX_VALUE_LENGTH; i++) {
+            value.append('a');
+        }
+        longValue = value.toString();
+
+        StringBuffer name = new StringBuffer(Preferences.MAX_NAME_LENGTH);
+        for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) {
+            name.append('a');
+        }
+        longName = name.toString();
+    }
+
+    protected void setUp() throws Exception {
+        super.setUp();
+        root = (AbstractPreferences) Preferences.userRoot();
+        parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+        // FIXME: change here is dangerous
+        // pref = new MockAbstractPreferences((AbstractPreferences) parent,
+        // "mock");
+
+        pref = (AbstractPreferences) parent.node("mock");
+    }
+
+    protected void tearDown() throws Exception {
+        try {
+            if (pref instanceof MockAbstractPreferences) {
+                ((MockAbstractPreferences) pref)
+                        .setResult(MockAbstractPreferences.NORMAL);
+            }
+            pref.removeNode();
+        } catch (Exception e) {
+        }
+        super.tearDown();
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "AbstractPreferences",
+          methodArgs = {java.util.prefs.AbstractPreferences.class, java.lang.String.class}
+        )
+    })
+    public void testConstructor() throws BackingStoreException {
+        try {
+            pref = new MockAbstractPreferences(
+                    (AbstractPreferences) Preferences.userRoot(), "mo/ck");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref = new MockAbstractPreferences(null, "mock");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            new MockAbstractPreferences(null, " ");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            new MockAbstractPreferences(pref, "");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            new MockAbstractPreferences(pref, null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        new MockAbstractPreferences(pref, " ");
+
+        Preferences p2 = new MockAbstractPreferences(null, "");
+        assertNotSame(p2, Preferences.systemRoot());
+        assertNotSame(p2, Preferences.userRoot());
+        assertFalse(p2.isUserNode());
+
+        p2 = new MockAbstractPreferences((AbstractPreferences) Preferences
+                .userRoot(), "mock");
+        assertNotSame(p2, pref);
+        p2.removeNode();
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "!Constants",
+      targets = {
+        @TestTarget(
+          methodName = "absolutePath",
+          methodArgs = {}
+        )
+    })
+    public void testProtectedFields() throws BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = new MockAbstractPreferences(pref, "newNode");
+        assertFalse(p.getNewNode());
+        assertSame(p.getLock().getClass(), Object.class);
+
+        p = (MockAbstractPreferences) pref.node("child");
+        assertTrue(p.getNewNode());
+
+        p = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
+                .publicChildSpi("child2");
+        assertTrue(p.getNewNode());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
+    public void testToString() {
+        assertEquals("User Preference Node: " + pref.absolutePath(), pref
+                .toString());
+
+        pref = new MockAbstractPreferences((AbstractPreferences) Preferences
+                .systemRoot(), "mock");
+        assertEquals("System Preference Node: " + pref.absolutePath(), pref
+                .toString());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "absolutePath",
+          methodArgs = {}
+        )
+    })
+    public void testAbsolutePath() {
+        assertEquals("/java/util/prefs/mock", pref.absolutePath());
+
+        pref = new MockAbstractPreferences(pref, " ");
+        assertEquals("/java/util/prefs/mock/ ", pref.absolutePath());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Exceptions checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        )
+    })
+    public void testChildrenNames() throws BackingStoreException {
+        assertEquals(0, pref.childrenNames().length);
+
+        Preferences child1 = pref.node("child1");
+
+        pref.node("child2");
+        pref.node("child3");
+        child1.node("subchild1");
+
+        assertSame(pref, child1.parent());
+        assertEquals(3, pref.childrenNames().length);
+        assertEquals("child1", pref.childrenNames()[0]);
+        assertEquals(1, child1.childrenNames().length);
+        assertEquals("subchild1", child1.childrenNames()[0]);
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Exceptions checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        )
+    })
+    public void testClear() throws BackingStoreException {
+        pref.put("testClearKey", "testClearValue");
+        pref.put("testClearKey1", "testClearValue1");
+        assertEquals("testClearValue", pref.get("testClearKey", null));
+        assertEquals("testClearValue1", pref.get("testClearKey1", null));
+        pref.clear();
+        assertNull(pref.get("testClearKey", null));
+        assertNull(pref.get("testClearKey1", null));
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testGet() throws BackingStoreException {
+        assertNull(pref.get("", null));
+        assertEquals("default", pref.get("key", "default"));
+        assertNull(pref.get("key", null));
+        pref.put("testGetkey", "value");
+        assertNull(pref.get("testGetKey", null));
+        assertEquals("value", pref.get("testGetkey", null));
+
+        try {
+            pref.get(null, "abc");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.get("", "abc");
+        pref.get("key", null);
+        pref.get("key", "");
+        pref.putFloat("floatKey", 1.0f);
+        assertEquals("1.0", pref.get("floatKey", null));
+
+        pref.removeNode();
+        try {
+            pref.get("key", "abc");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.get(null, "abc");
+            fail();
+        } catch (NullPointerException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        )
+    })
+    public void testGetBoolean() {
+        try {
+            pref.getBoolean(null, false);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetBooleanKey", "false");
+        pref.put("testGetBooleanKey2", "value");
+        assertFalse(pref.getBoolean("testGetBooleanKey", true));
+        assertTrue(pref.getBoolean("testGetBooleanKey2", true));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        )
+    })
+    public void testPutByteArray() {
+        try {
+            pref.putByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.putByteArray("testPutByteArrayKey4", null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.putByteArray(longKey, new byte[0]);
+        try {
+            pref.putByteArray(longKey + "a", new byte[0]);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        byte[] longArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.74)];
+        byte[] longerArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.75) + 1];
+        pref.putByteArray(longKey, longArray);
+        try {
+            pref.putByteArray(longKey, longerArray);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        pref.putByteArray("testPutByteArrayKey", new byte[0]);
+        assertEquals("", pref.get("testPutByteArrayKey", null));
+        assertTrue(Arrays.equals(new byte[0], pref.getByteArray(
+                "testPutByteArrayKey", null)));
+
+        pref.putByteArray("testPutByteArrayKey3", new byte[] { 'a', 'b', 'c' });
+        assertEquals("YWJj", pref.get("testPutByteArrayKey3", null));
+        assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
+                .getByteArray("testPutByteArrayKey3", null)));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        )
+    })
+    public void testGetByteArray() throws UnsupportedEncodingException {
+        try {
+            pref.getByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        byte[] b64Array = new byte[] { 0x59, 0x57, 0x4a, 0x6a };// BASE64
+        // encoding for
+        // "abc"
+
+        pref.put("testGetByteArrayKey", "abc=");
+        pref.put("testGetByteArrayKey2", new String(b64Array));
+        pref.put("invalidKey", "<>?");
+        // assertTrue(Arrays.equals(new byte[0], p.getByteArray(
+        // "testGetByteArrayKey", new byte[0])));
+        assertTrue(Arrays.equals(new byte[] { 105, -73 }, pref.getByteArray(
+                "testGetByteArrayKey", new byte[0])));
+        assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
+                .getByteArray("testGetByteArrayKey2", new byte[0])));
+        assertTrue(Arrays.equals(new byte[0], pref.getByteArray("invalidKey",
+                new byte[0])));
+
+        pref.putByteArray("testGetByteArrayKey3", b64Array);
+        pref.putByteArray("testGetByteArrayKey4", "abc".getBytes());
+        assertTrue(Arrays.equals(b64Array, pref.getByteArray(
+                "testGetByteArrayKey3", new byte[0])));
+        assertTrue(Arrays.equals("abc".getBytes(), pref.getByteArray(
+                "testGetByteArrayKey4", new byte[0])));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        )
+    })
+    public void testGetDouble() {
+        try {
+            pref.getDouble(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetDoubleKey", "1");
+        pref.put("testGetDoubleKey2", "value");
+        pref.putDouble("testGetDoubleKey3", 1);
+        pref.putInt("testGetDoubleKey4", 1);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey", 0.0), 0);
+        assertEquals(0.0, pref.getDouble("testGetDoubleKey2", 0.0), 0);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey3", 0.0), 0);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey4", 0.0), 0);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        )
+    })
+    public void testGetFloat() {
+        try {
+            pref.getFloat(null, 0f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.put("testGetFloatKey", "1");
+        pref.put("testGetFloatKey2", "value");
+        assertEquals(1f, pref.getFloat("testGetFloatKey", 0f), 0); //$NON-NLS-1$
+        assertEquals(0f, pref.getFloat("testGetFloatKey2", 0f), 0);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getInt",
+          methodArgs = {java.lang.String.class, int.class}
+        )
+    })
+    public void testGetInt() {
+        try {
+            pref.getInt(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetIntKey", "1");
+        pref.put("testGetIntKey2", "value");
+        assertEquals(1, pref.getInt("testGetIntKey", 0));
+        assertEquals(0, pref.getInt("testGetIntKey2", 0));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "getLong",
+          methodArgs = {java.lang.String.class, long.class}
+        )
+    })
+    public void testGetLong() {
+        try {
+            pref.getLong(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetLongKey", "1");
+        pref.put("testGetLongKey2", "value");
+        assertEquals(1, pref.getInt("testGetLongKey", 0));
+        assertEquals(0, pref.getInt("testGetLongKey2", 0));
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "isUserNode",
+          methodArgs = {}
+        )
+    })
+    public void testIsUserNode() {
+        assertTrue(pref.isUserNode());
+
+        pref = new MockAbstractPreferences((AbstractPreferences) Preferences
+                .systemRoot(), "mock");
+        assertFalse(pref.isUserNode());
+    }
+
+    // TODO, how to test the "stored defaults"
+    // TODO, how to test the multi-thread
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Exceptions checking missed. Probably todo list reasonable for functional stress test.",
+      targets = {
+        @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        )
+    })
+    public void testKeys() throws BackingStoreException {
+        assertEquals(0, pref.keys().length);
+
+        pref.put("key0", "value");
+        pref.put("key1", "value1");
+        pref.put("key2", "value2");
+        pref.put("key3", "value3");
+
+        String[] keys = pref.keys();
+        assertEquals(4, keys.length);
+        for (int i = 0; i < keys.length; i++) {
+            assertEquals(0, keys[i].indexOf("key"));
+            assertEquals(4, keys[i].length());
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "name",
+          methodArgs = {}
+        )
+    })
+    public void testName() {
+        assertEquals("mock", pref.name());
+
+        pref = new MockAbstractPreferences(pref, " ");
+        assertEquals(" ", pref.name());
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Functional test for keys with special symbols. No exceptions were checked.",
+      targets = {
+        @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testCharCase() throws BackingStoreException {
+        assertSame(pref.node("samechild"), pref.node("samechild"));
+        assertNotSame(pref.node("sameChild"), pref.node("samechild"));
+        assertNotSame(pref.node("child"), pref.node("Child"));
+        assertNotSame(pref.node("child"), pref.node("Child"));
+        assertNotSame(pref.node("child"), pref.node(" child"));
+        String[] names = pref.childrenNames();
+        assertEquals(5, names.length);
+        for (int i = 0; i < names.length; i++) {
+            String name = names[i];
+            assertTrue("samechild".equals(name) || "sameChild".equals(name)
+                    || "child".equals(name) || "Child".equals(name)
+                    || " child".equals(name));
+        }
+
+        Preferences mock1 = pref.node("mock1");
+        mock1.put("key", "1value");
+        mock1.put("KEY", "2value");
+        mock1.put("/K/E/Y", "7value");
+        mock1.put("/K/E\\Y\\abc~@!#$%^&*(\\", "8value");
+
+        assertEquals("8value", mock1.get("/K/E\\Y\\abc~@!#$%^&*(\\", null));
+        assertNull(mock1.get("/k/e/y", null));
+        assertEquals("7value", mock1.get("/K/E/Y", null));
+        assertEquals("1value", mock1.get("key", null));
+
+        String[] keys = mock1.keys();
+        assertEquals(4, keys.length);
+        for (int i = 0; i < keys.length; i++) {
+            String key = keys[i];
+            assertTrue("key".equals(key) || "KEY".equals(key)
+                    || "/K/E/Y".equals(key)
+                    || "/K/E\\Y\\abc~@!#$%^&*(\\".equals(key));
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "node",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testNode() throws BackingStoreException {
+        try {
+            pref.node(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.node("/java/util/prefs/");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.node("/java//util/prefs");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.node(longName + "a");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        assertNotNull(pref.node(longName));
+
+        assertSame(root, pref.node("/"));
+
+        Preferences prefs = pref.node("/java/util/prefs");
+        assertSame(prefs, parent);
+
+        assertSame(pref, pref.node(""));
+
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences child = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
+                .publicChildSpi("child");
+        assertSame(child, pref.node("child"));
+
+        Preferences child2 = pref.node("child2");
+        assertSame(child2, ((MockAbstractPreferences) pref)
+                .publicChildSpi("child2"));
+
+        Preferences grandchild = pref.node("child/grandchild");
+        assertSame(grandchild, child.childSpi("grandchild"));
+        assertSame(grandchild, child.cachedChildrenImpl()[0]);
+        grandchild.removeNode();
+        assertNotSame(grandchild, pref.node("child/grandchild"));
+
+        grandchild = pref.node("child3/grandchild");
+        AbstractPreferences[] childs = ((MockAbstractPreferences) pref)
+                .cachedChildrenImpl();
+        Preferences child3 = child;
+        for (int i = 0; i < childs.length; i++) {
+            if (childs[i].name().equals("child3")) {
+                child3 = childs[i];
+                break;
+            }
+        }
+        assertSame(child3, grandchild.parent());
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "nodeExists",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testNodeExists() throws BackingStoreException {
+        try {
+            pref.nodeExists(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.nodeExists("/java/util/prefs/");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.nodeExists("/java//util/prefs");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        assertTrue(pref.nodeExists("/"));
+
+        assertTrue(pref.nodeExists("/java/util/prefs"));
+
+        assertTrue(pref.nodeExists(""));
+
+        assertFalse(pref.nodeExists("child"));
+        Preferences grandchild = pref.node("child/grandchild");
+        assertTrue(pref.nodeExists("child"));
+        assertTrue(pref.nodeExists("child/grandchild"));
+        grandchild.removeNode();
+        assertTrue(pref.nodeExists("child"));
+        assertFalse(pref.nodeExists("child/grandchild"));
+        assertFalse(grandchild.nodeExists(""));
+
+        assertFalse(pref.nodeExists("child2/grandchild"));
+        pref.node("child2/grandchild");
+        assertTrue(pref.nodeExists("child2/grandchild"));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "parent",
+          methodArgs = {}
+        )
+    })
+    public void testParent() {
+        assertSame(parent, pref.parent());
+        AbstractPreferences child1 = new MockAbstractPreferences(pref, "child1");
+        assertSame(pref, child1.parent());
+        assertNull(root.parent());
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Missed check for max values: MAX_KEY_LENGTH, MAX_NAME_LENGTH, MAX_VALUE_LENGTH",
+      targets = {
+        @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testPut() throws BackingStoreException {
+        pref.put("", "emptyvalue");
+        assertEquals("emptyvalue", pref.get("", null));
+        pref.put("testPutkey", "value1");
+        assertEquals("value1", pref.get("testPutkey", null));
+        pref.put("testPutkey", "value2");
+        assertEquals("value2", pref.get("testPutkey", null));
+
+        pref.put("", "emptyvalue");
+        assertEquals("emptyvalue", pref.get("", null));
+
+        try {
+            pref.put(null, "value");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.put("key", null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.put(longKey, longValue);
+        try {
+            pref.put(longKey + 1, longValue);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.put(longKey, longValue + 1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        pref.removeNode();
+        try {
+            pref.put(longKey, longValue + 1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        try {
+            pref.put(longKey, longValue);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        )
+    })
+    public void testPutBoolean() {
+        try {
+            pref.putBoolean(null, false);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putBoolean(longKey, false);
+        try {
+            pref.putBoolean(longKey + "a", false);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putBoolean("testPutBooleanKey", false);
+        assertEquals("false", pref.get("testPutBooleanKey", null));
+        assertFalse(pref.getBoolean("testPutBooleanKey", true));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "putDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        )
+    })
+    public void testPutDouble() {
+        try {
+            pref.putDouble(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putDouble(longKey, 3);
+        try {
+            pref.putDouble(longKey + "a", 3);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putDouble("testPutDoubleKey", 3);
+        assertEquals("3.0", pref.get("testPutDoubleKey", null));
+        assertEquals(3, pref.getDouble("testPutDoubleKey", 0), 0);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        )
+    })
+    public void testPutFloat() {
+        try {
+            pref.putFloat(null, 3f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putFloat(longKey, 3f);
+        try {
+            pref.putFloat(longKey + "a", 3f);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putFloat("testPutFloatKey", 3f);
+        assertEquals("3.0", pref.get("testPutFloatKey", null));
+        assertEquals(3f, pref.getFloat("testPutFloatKey", 0), 0);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        )
+    })
+    public void testPutInt() {
+        try {
+            pref.putInt(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putInt(longKey, 3);
+        try {
+            pref.putInt(longKey + "a", 3);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putInt("testPutIntKey", 3);
+        assertEquals("3", pref.get("testPutIntKey", null));
+        assertEquals(3, pref.getInt("testPutIntKey", 0));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        )
+    })
+    public void testPutLong() {
+        try {
+            pref.putLong(null, 3L);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putLong(longKey, 3L);
+        try {
+            pref.putLong(longKey + "a", 3L);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putLong("testPutLongKey", 3L);
+        assertEquals("3", pref.get("testPutLongKey", null));
+        assertEquals(3L, pref.getLong("testPutLongKey", 0));
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "remove",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testRemove() throws BackingStoreException {
+        pref.remove("key");
+
+        pref.put("key", "value");
+        assertEquals("value", pref.get("key", null));
+        pref.remove("key");
+        assertNull(pref.get("key", null));
+
+        pref.remove("key");
+
+        try {
+            pref.remove(null);
+        } catch (NullPointerException e) {
+        }
+
+        pref.removeNode();
+        try {
+            pref.remove("key");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Exceptions checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        )
+    })
+    public void testRemoveNode() throws BackingStoreException {
+        Preferences child = pref.node("child");
+        Preferences child1 = pref.node("child1");
+        Preferences grandchild = child.node("grandchild");
+
+        pref.removeNode();
+
+        assertFalse(child.nodeExists(""));
+        assertFalse(child1.nodeExists(""));
+        assertFalse(grandchild.nodeExists(""));
+        assertFalse(pref.nodeExists(""));
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Also checks event flow.",
+      targets = {
+        @TestTarget(
+          methodName = "addNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        )
+    })
+    public void _testAddNodeChangeListener() throws BackingStoreException {
+        try {
+            pref.addNodeChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        Preferences child1 = null;
+        Preferences child2 = null;
+        Preferences child3 = null;
+        // To get existed node doesn't create the change event
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock1");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+            child2 = pref.node("mock1");
+            assertEquals(0, nl.getAdded());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            child1.removeNode();
+        }
+        // same listener can be added twice, and must be removed twice
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock2");
+            assertEquals(2, nl.getAdded());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            pref.removeNodeChangeListener(nl);
+            child1.removeNode();
+        }
+        // test remove event
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock3");
+            child1.removeNode();
+            assertEquals(1, nl.getRemoved());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+        }
+        // test remove event with two listeners
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock6");
+            child1.removeNode();
+            assertEquals(2, nl.getRemoved());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            pref.removeNodeChangeListener(nl);
+        }
+        // test add/remove indirect children, or remove several children at the
+        // same time
+        try {
+            nl = new MockNodeChangeListener();
+            child1 = pref.node("mock4");
+            child1.addNodeChangeListener(nl);
+            child2 = pref.node("mock4/mock5");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+            child3 = pref.node("mock4/mock5/mock6");
+            assertEquals(0, nl.getAdded());
+            nl.reset();
+
+            child3.removeNode();
+            assertEquals(0, nl.getRemoved());
+            nl.reset();
+
+            child3 = pref.node("mock4/mock7");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+
+            child1.removeNode();
+            assertEquals(2, nl.getRemoved());
+            nl.reset();
+        } finally {
+            try {
+                child1.removeNode();
+            } catch (Exception e) {
+            }
+        }
+
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Also checks event flow.",
+      targets = {
+        @TestTarget(
+          methodName = "addPreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        )
+    })
+    public void _testAddPreferenceChangeListener() {
+        // TODO: start from here
+        try {
+            pref.addPreferenceChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        // To get existed node doesn't create the change event
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.putInt("mock1", 123);
+            assertEquals(1, pl.getChanged());
+            pref.putLong("long_key", Long.MAX_VALUE);
+            assertEquals(2, pl.getChanged());
+            pl.reset();
+
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+            //child1.removeNode();
+        }
+                      
+        // same listener can be added twice, and must be removed twice
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.addPreferenceChangeListener(pl);
+            pref.putFloat("float_key", Float.MIN_VALUE);
+            assertEquals(2, pl.getChanged());
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+            pref.removePreferenceChangeListener(pl);
+
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "removeNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        )
+    })
+    public void testRemoveNodeChangeListener() {
+        try {
+            pref.removeNodeChangeListener(null);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        MockNodeChangeListener l1 = new MockNodeChangeListener();
+        MockNodeChangeListener l2 = new MockNodeChangeListener();
+        pref.addNodeChangeListener(l1);
+        pref.addNodeChangeListener(l1);
+
+        pref.removeNodeChangeListener(l1);
+        pref.removeNodeChangeListener(l1);
+        try {
+            pref.removeNodeChangeListener(l1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.removeNodeChangeListener(l2);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "removePreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        )
+    })
+    public void testRemovePreferenceChangeListener() {
+        try {
+            pref.removePreferenceChangeListener(null);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        MockPreferenceChangeListener l1 = new MockPreferenceChangeListener();
+        MockPreferenceChangeListener l2 = new MockPreferenceChangeListener();
+        pref.addPreferenceChangeListener(l1);
+        pref.addPreferenceChangeListener(l1);
+        try {
+            pref.removePreferenceChangeListener(l2);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.removePreferenceChangeListener(l1);
+        pref.removePreferenceChangeListener(l1);
+        try {
+            pref.removePreferenceChangeListener(l1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Exceptions checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        )
+    })
+    public void testSync() throws BackingStoreException {
+
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.resetSyncTimes();
+        p.sync();
+        assertEquals(1, p.getSyncTimes());
+
+        p.resetSyncTimes();
+        MockAbstractPreferences child = (MockAbstractPreferences) p
+                .node("child");
+        MockAbstractPreferences child2 = new MockAbstractPreferences(p,
+                "child2");
+        p.childs.put("child2", child2);
+        assertEquals(1, p.cachedChildrenImpl().length);
+        assertSame(child, p.cachedChildrenImpl()[0]);
+        p.sync();
+        assertEquals(1, p.getSyncTimes());
+        assertEquals(1, child.getSyncTimes());
+        assertEquals(0, child2.getSyncTimes());
+
+        p.resetSyncTimes();
+        child.resetSyncTimes();
+        child.sync();
+        assertEquals(0, p.getSyncTimes());
+        assertEquals(1, child.getSyncTimes());
+
+        p.resetSyncTimes();
+        child.resetSyncTimes();
+        MockAbstractPreferences grandson = (MockAbstractPreferences) child
+                .node("grandson");
+        child.sync();
+        assertEquals(0, p.getSyncTimes());
+        assertEquals(1, child.getSyncTimes());
+        assertEquals(1, grandson.getSyncTimes());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "flush",
+          methodArgs = {}
+        )
+    })
+    public void testFlush() throws BackingStoreException {
+        
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.resetFlushedTimes();
+        p.flush();
+        assertEquals(1, p.getFlushedTimes());
+
+        p.resetFlushedTimes();
+        MockAbstractPreferences child = (MockAbstractPreferences) p
+                .node("child");
+        MockAbstractPreferences child2 = new MockAbstractPreferences(p,
+                "child2");
+        p.childs.put("child2", child2);
+        assertEquals(1, p.cachedChildrenImpl().length);
+        assertSame(child, p.cachedChildrenImpl()[0]);
+        p.flush();
+        assertEquals(1, p.getFlushedTimes());
+        assertEquals(1, child.getFlushedTimes());
+        assertEquals(0, child2.getFlushedTimes());
+
+        p.resetFlushedTimes();
+        child.resetFlushedTimes();
+        child.flush();
+        assertEquals(0, p.getFlushedTimes());
+        assertEquals(1, child.getFlushedTimes());
+
+        p.resetFlushedTimes();
+        child.resetFlushedTimes();
+        MockAbstractPreferences grandson = (MockAbstractPreferences) child
+                .node("grandson");
+        child.flush();
+        assertEquals(0, p.getFlushedTimes());
+        assertEquals(1, child.getFlushedTimes());
+        assertEquals(1, grandson.getFlushedTimes());
+
+        p.resetFlushedTimes();
+        child.resetFlushedTimes();
+        grandson.resetFlushedTimes();
+        child.removeNode();
+        child.flush();
+        assertEquals(0, p.getFlushedTimes());
+        assertEquals(1, child.getFlushedTimes());
+        assertEquals(0, grandson.getFlushedTimes());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getChild",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testGetChild() throws BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        assertNull(p.getChildImpl("child"));
+        MockAbstractPreferences child = new MockAbstractPreferences(p, "child");
+        p.childs.put("child", child);
+        assertSame(child, p.getChildImpl("child"));
+        assertNull(p.getChildImpl("child "));
+
+        assertNull(p.getChildImpl("child/grandson"));
+        child.childs.put("grandson", new MockAbstractPreferences(child,
+                "grandson"));
+        assertNull(p.getChildImpl("child/grandson"));
+
+        assertNull(p.getChildImpl(null));
+        assertNull(p.getChildImpl(""));
+        assertNull(p.getChildImpl(" "));
+        assertNull(p.getChildImpl("abc//abc"));
+        assertNull(p.getChildImpl("child/"));
+        assertNull(p.getChildImpl(longName + "a"));
+
+        child.removeNode();
+        assertNull(p.getChildImpl("child"));
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "isRemoved",
+          methodArgs = {}
+        )
+    })
+    public void testIsRemoved() throws BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        assertFalse(p.isRemovedImpl());
+        p.removeNode();
+        assertTrue(p.isRemovedImpl());
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IOException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        )
+    })
+    public void _testExportNode() throws Exception {
+        try {
+            pref.exportNode(null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+
+        pref.putBoolean("key", false);
+        Preferences child = pref.node("child<");
+        child.put("key2", "value2<");
+        Preferences grandson = child.node("grandson");
+        grandson.put("key3", "value3");
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        child.exportNode(out);
+
+        byte[] result = out.toString().getBytes();
+        ByteArrayInputStream in = new ByteArrayInputStream(result);
 
                 try {
-		    parseXmlStream(in, true);
+            parseXmlStream(in, true);
                 } catch (Exception ee) {
                     fail("Exception " + ee + " does not expected");
                 }
-	}
-
-	private static Document parseXmlStream(InputStream input, boolean validating)
-			throws SAXException, IOException, ParserConfigurationException {
-		// Create a builder factory
-		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
-		factory.setValidating(validating);
-
-		// Create the builder and parse the file
-		DocumentBuilder builder = factory.newDocumentBuilder();
-		Document doc = builder.parse(input);
-		return doc;
-	}
-
-	public void testExportSubtree() throws Exception {
-		try {
-			pref.exportSubtree(null);
-			fail();
-		} catch (NullPointerException e) {
-			// Expected
-		}
-		ByteArrayOutputStream out = new ByteArrayOutputStream();
-		pref.putBoolean("key", false);
-		Preferences child = pref.node("child");
-		child.put("key2", "value2");
-		Preferences grandson = child.node("grandson");
-		grandson.put("key3", "value3");
-		child.node("grandson2");
-		Preferences grandgrandson = grandson.node("grandgrandson");
-		grandgrandson.put("key4", "value4");
-		child.exportSubtree(out);
-
-		byte[] result = out.toByteArray();
-		// System.out.println(new String(result, "utf-8"));
-		ByteArrayInputStream in = new ByteArrayInputStream(result);
+    }
+
+    private static Document parseXmlStream(InputStream input, boolean validating)
+            throws SAXException, IOException, ParserConfigurationException {
+        // Create a builder factory
+        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+        factory.setValidating(validating);
+
+        // Create the builder and parse the file
+        DocumentBuilder builder = factory.newDocumentBuilder();
+        Document doc = builder.parse(input);
+        return doc;
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IOException checking missed",
+      targets = {
+        @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        )
+    })
+    public void _testExportSubtree() throws Exception {
+        try {
+            pref.exportSubtree(null);
+            fail();
+        } catch (NullPointerException e) {
+            // Expected
+        }
+        ByteArrayOutputStream out = new ByteArrayOutputStream();
+        pref.putBoolean("key", false);
+        Preferences child = pref.node("child");
+        child.put("key2", "value2");
+        Preferences grandson = child.node("grandson");
+        grandson.put("key3", "value3");
+        child.node("grandson2");
+        Preferences grandgrandson = grandson.node("grandgrandson");
+        grandgrandson.put("key4", "value4");
+        child.exportSubtree(out);
+
+        byte[] result = out.toByteArray();
+        // System.out.println(new String(result, "utf-8"));
+        ByteArrayInputStream in = new ByteArrayInputStream(result);
 
                 try {
-		    parseXmlStream(in, true);
+            parseXmlStream(in, true);
                 } catch (Exception ee) {
                     fail("Exception " + ee + " does not expected");
                 }
-	}
-
-	public void testCachedChildren() throws Exception {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		assertEquals(0, p.cachedChildrenImpl().length);
-
-		MockAbstractPreferences child = (MockAbstractPreferences) p
-				.getChildImpl("child");
-		assertNull(child);
-
-		child = new MockAbstractPreferences(p, "child");
-		assertSame(child, p.getChildImpl("child"));
-
-		assertEquals(0, p.cachedChildrenImpl().length);
-
-		p.node("child");
-		assertSame(child, p.cachedChildrenImpl()[0]);
-
-		MockAbstractPreferences grandchild = new MockAbstractPreferences(child,
-				"grandchild");
-		assertSame(grandchild, child.getChildImpl("grandchild"));
-		assertNull(p.getChildImpl("grandchild"));
-
-		assertEquals(1, p.cachedChildrenImpl().length);
-		assertEquals(0, child.cachedChildrenImpl().length);
-
-		p.node("child/grandchild");
-		assertSame(child, p.cachedChildrenImpl()[0]);
-		assertSame(grandchild, child.cachedChildrenImpl()[0]);
-		assertEquals(1, p.cachedChildrenImpl().length);
-		assertEquals(1, child.cachedChildrenImpl().length);
-
-		p.childs.put("child2", new MockAbstractPreferences(p, "child2"));
-		p.nodeExists("child2/grandchild");
-		assertSame(child, p.cachedChildrenImpl()[0]);
-		assertSame(grandchild, child.cachedChildrenImpl()[0]);
-		assertEquals(1, p.cachedChildrenImpl().length);
-		assertEquals(1, child.cachedChildrenImpl().length);
-	}
-
-	public void testAbstractMethod() {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		((MockAbstractPreferences) pref).protectedAbstractMethod();
-	}
-
-	public Object invokeNonPublicMethod(AbstractPreferences obj, String name,
-			Class[] params, Object[] paramValues) throws SecurityException,
-			NoSuchMethodException, IllegalArgumentException,
-			IllegalAccessException, InvocationTargetException {
-		Method method = obj.getClass().getMethod(name, params);
-		method.setAccessible(true);
-		return method.invoke(obj, paramValues);
-	}
-
-	public void testBackingStoreException() throws IOException,
-			BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.setResult(MockAbstractPreferences.backingException);
-		try {
-			p.childrenNames();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.put("exceptionkey", "value");
-		p.absolutePath();
-		p.toString();
-		assertEquals("exception default", p.get("key", "exception default"));
-		p.remove("key");
-		try {
-			p.clear();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.putInt("key", 3);
-		p.getInt("key", 3);
-		p.putLong("key", 3l);
-		p.getLong("key", 3l);
-		p.putDouble("key", 3);
-		p.getDouble("key", 3);
-		p.putBoolean("key", true);
-		p.getBoolean("key", true);
-		p.putFloat("key", 3f);
-		p.getFloat("key", 3f);
-		p.putByteArray("key", new byte[0]);
-		p.getByteArray("key", new byte[0]);
-		try {
-			p.keys();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-
-		try {
-			p.keys();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		try {
-			p.childrenNames();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.parent();
-		p.node("");
-		p.nodeExists("");
-		try {
-			p.removeNode();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.name();
-		p.absolutePath();
-		p.isUserNode();
-		MockPreferenceChangeListener mockPreferenceChangeListener = new MockPreferenceChangeListener();
-		p.addPreferenceChangeListener(mockPreferenceChangeListener);
-		p.removePreferenceChangeListener(mockPreferenceChangeListener);
-		MockNodeChangeListener mockNodeChangeListener = new MockNodeChangeListener();
-		p.addNodeChangeListener(mockNodeChangeListener);
-		p.removeNodeChangeListener(mockNodeChangeListener);
-		p.toString();
-		try {
-			p.sync();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		try {
-			p.flush();
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		try {
-			p.exportNode(new ByteArrayOutputStream());
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		try {
-			p.exportSubtree(new ByteArrayOutputStream());
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.isRemovedImpl();
-		try {
-			p.getChildImpl(null);
-			fail();
-		} catch (BackingStoreException e) {
-		}
-		p.cachedChildrenImpl();
-	}
-
-	public void testRuntimeException() throws IOException,
-			BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.setResult(MockAbstractPreferences.runtimeException);
-		try {
-			p.childrenNames();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.put("exceptionkey", "value");
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.absolutePath();
-		p.toString();
-		assertEquals("exception default", p.get("key", "exception default"));
-		try {
-			p.remove("key");
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.clear();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.putInt("key", 3);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getInt("key", 3);
-		try {
-			p.putLong("key", 3l);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getLong("key", 3l);
-		try {
-			p.putDouble("key", 3);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getDouble("key", 3);
-		try {
-			p.putBoolean("key", true);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getBoolean("key", true);
-		try {
-			p.putFloat("key", 3f);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getFloat("key", 3f);
-		try {
-			p.putByteArray("key", new byte[0]);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.getByteArray("key", new byte[0]);
-		try {
-			p.keys();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.keys();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.childrenNames();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.parent();
-		p.node("");
-		p.nodeExists("");
-		try {
-			p.removeNode();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.name();
-		p.absolutePath();
-		p.isUserNode();
-		MockPreferenceChangeListener pcl = new MockPreferenceChangeListener();
-		p.addPreferenceChangeListener(pcl);
-		p.removePreferenceChangeListener(pcl);
-		MockNodeChangeListener ncl = new MockNodeChangeListener();
-		p.addNodeChangeListener(ncl);
-		p.removeNodeChangeListener(ncl);
-		p.toString();
-		try {
-			p.sync();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.flush();
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.exportNode(new ByteArrayOutputStream());
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		try {
-			p.exportSubtree(new ByteArrayOutputStream());
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.isRemovedImpl();
-		try {
-			p.getChildImpl(null);
-			fail();
-		} catch (MockRuntimeException e) {
-		}
-		p.cachedChildrenImpl();
-	}
-
-	public void testSPIReturnNull() throws IOException, BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.setResult(MockAbstractPreferences.returnNull);
-		try {
-			p.childrenNames();
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.absolutePath();
-		p.toString();
-		p.put("nullkey", "value");
-		assertEquals("null default", p.get("key", "null default"));
-		p.remove("key");
-		try {
-			p.clear();
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.putInt("key", 3);
-		p.getInt("key", 3);
-		p.putLong("key", 3l);
-		p.getLong("key", 3l);
-		p.putDouble("key", 3);
-		p.getDouble("key", 3);
-		p.putBoolean("key", true);
-		p.getBoolean("key", true);
-		p.putFloat("key", 3f);
-		p.getFloat("key", 3f);
-		p.putByteArray("key", new byte[0]);
-		p.getByteArray("key", new byte[0]);
-		p.keys();
-		try {
-			p.childrenNames();
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.parent();
-		p.node("");
-		p.nodeExists("");
-		try {
-			p.removeNode();
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.name();
-		p.absolutePath();
-		p.isUserNode();
-		MockPreferenceChangeListener mockPreferenceChangeListener = new MockPreferenceChangeListener();
-		p.addPreferenceChangeListener(mockPreferenceChangeListener);
-		p.removePreferenceChangeListener(mockPreferenceChangeListener);
-		MockNodeChangeListener mockNodeChangeListener = new MockNodeChangeListener();
-		p.addNodeChangeListener(mockNodeChangeListener);
-		p.removeNodeChangeListener(mockNodeChangeListener);
-		p.toString();
-		p.sync();
-		p.flush();
-		try {
-			p.exportNode(System.out);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.exportSubtree(System.out);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.isRemovedImpl();
-		try {
-			p.getChildImpl("");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		p.cachedChildrenImpl();
-	}
-
-	public void testIllegalStateException() throws IOException,
-			BackingStoreException {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		pref.removeNode();
-		// after remove node, every methods, except name(), absolutePath(),
-		// isUserNode(), flush() or nodeExists(""),
-		// will throw illegal state exception
-		pref.nodeExists("");
-		pref.name();
-		pref.absolutePath();
-		pref.isUserNode();
-		pref.toString();
-		pref.flush();
-		try {
-			pref.nodeExists("child");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.childrenNames();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.remove(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.clear();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.get("key", "null default");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.put("nullkey", "value");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putInt("key", 3);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getInt("key", 3);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putLong("key", 3l);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getLong("key", 3l);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putDouble("key", 3);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getDouble("key", 3);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putBoolean("key", true);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getBoolean("key", true);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putFloat("key", 3f);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getFloat("key", 3f);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.putByteArray("key", new byte[0]);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.getByteArray("key", new byte[0]);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.keys();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.keys();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.childrenNames();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.parent();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.node(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.removeNode();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref
-					.addPreferenceChangeListener(new MockPreferenceChangeListener());
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref
-					.removePreferenceChangeListener(new MockPreferenceChangeListener());
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.addNodeChangeListener(new MockNodeChangeListener());
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.removeNodeChangeListener(new MockNodeChangeListener());
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.sync();
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.exportNode(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.exportSubtree(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.isRemovedImpl();
-		p.cachedChildrenImpl();
-		try {
-			p.getChildImpl(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
-
-	public void testNullAndIllegalStateException() throws Exception {
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences p = (MockAbstractPreferences) pref;
-		p.removeNode();
-		try {
-			p.get(null, "null default");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.put(null, "value");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putInt(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getInt(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putLong(null, 3l);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getLong(null, 3l);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putDouble(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getDouble(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putBoolean(null, true);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getBoolean(null, true);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putFloat(null, 3f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getFloat(null, 3f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.putByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.getByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.addPreferenceChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.removePreferenceChangeListener(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			p.addNodeChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			p.removeNodeChangeListener(null);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "cachedChildren",
+          methodArgs = {}
+        )
+    })
+    public void testCachedChildren() throws Exception {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        assertEquals(0, p.cachedChildrenImpl().length);
+
+        MockAbstractPreferences child = (MockAbstractPreferences) p
+                .getChildImpl("child");
+        assertNull(child);
+
+        child = new MockAbstractPreferences(p, "child");
+        assertSame(child, p.getChildImpl("child"));
+
+        assertEquals(0, p.cachedChildrenImpl().length);
+
+        p.node("child");
+        assertSame(child, p.cachedChildrenImpl()[0]);
+
+        MockAbstractPreferences grandchild = new MockAbstractPreferences(child,
+                "grandchild");
+        assertSame(grandchild, child.getChildImpl("grandchild"));
+        assertNull(p.getChildImpl("grandchild"));
+
+        assertEquals(1, p.cachedChildrenImpl().length);
+        assertEquals(0, child.cachedChildrenImpl().length);
+
+        p.node("child/grandchild");
+        assertSame(child, p.cachedChildrenImpl()[0]);
+        assertSame(grandchild, child.cachedChildrenImpl()[0]);
+        assertEquals(1, p.cachedChildrenImpl().length);
+        assertEquals(1, child.cachedChildrenImpl().length);
+
+        p.childs.put("child2", new MockAbstractPreferences(p, "child2"));
+        p.nodeExists("child2/grandchild");
+        assertSame(child, p.cachedChildrenImpl()[0]);
+        assertSame(grandchild, child.cachedChildrenImpl()[0]);
+        assertEquals(1, p.cachedChildrenImpl().length);
+        assertEquals(1, child.cachedChildrenImpl().length);
+    }
+
+@TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Candidate for removal.",
+      targets = {
+        @TestTarget(
+          methodName = "",
+          methodArgs = {}
+        )
+    })
+    public void testAbstractMethod() {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        ((MockAbstractPreferences) pref).protectedAbstractMethod();
+    }
+
+@TestInfo(
+          level = TestLevel.TODO,
+          purpose = "Candidate for removal.",
+          targets = {
+            @TestTarget(
+              methodName = "",
+              methodArgs = {}
+            )
+        })
+    public Object invokeNonPublicMethod(AbstractPreferences obj, String name,
+            Class[] params, Object[] paramValues) throws SecurityException,
+            NoSuchMethodException, IllegalArgumentException,
+            IllegalAccessException, InvocationTargetException {
+        Method method = obj.getClass().getMethod(name, params);
+        method.setAccessible(true);
+        return method.invoke(obj, paramValues);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Test checks BackingStoreException",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "flush",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "getChild",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void _testBackingStoreException() throws IOException,
+            BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            fail();
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.setResult(MockAbstractPreferences.backingException);
+        try {
+            p.childrenNames();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.put("exceptionkey", "value");
+        p.absolutePath();
+        p.toString();
+        assertEquals("exception default", p.get("key", "exception default"));
+        p.remove("key");
+        try {
+            p.clear();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.putInt("key", 3);
+        p.getInt("key", 3);
+        p.putLong("key", 3l);
+        p.getLong("key", 3l);
+        p.putDouble("key", 3);
+        p.getDouble("key", 3);
+        p.putBoolean("key", true);
+        p.getBoolean("key", true);
+        p.putFloat("key", 3f);
+        p.getFloat("key", 3f);
+        p.putByteArray("key", new byte[0]);
+        p.getByteArray("key", new byte[0]);
+        try {
+            p.keys();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+
+        try {
+            p.keys();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        try {
+            p.childrenNames();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.parent();
+        p.node("");
+        p.nodeExists("");
+        try {
+            p.removeNode();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.name();
+        p.absolutePath();
+        p.isUserNode();
+        MockPreferenceChangeListener mockPreferenceChangeListener = new MockPreferenceChangeListener();
+        p.addPreferenceChangeListener(mockPreferenceChangeListener);
+        p.removePreferenceChangeListener(mockPreferenceChangeListener);
+        MockNodeChangeListener mockNodeChangeListener = new MockNodeChangeListener();
+        p.addNodeChangeListener(mockNodeChangeListener);
+        p.removeNodeChangeListener(mockNodeChangeListener);
+        p.toString();
+        try {
+            p.sync();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        try {
+            p.flush();
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        try {
+            p.exportNode(new ByteArrayOutputStream());
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        try {
+            p.exportSubtree(new ByteArrayOutputStream());
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.isRemovedImpl();
+        try {
+            p.getChildImpl(null);
+            fail();
+        } catch (BackingStoreException e) {
+        }
+        p.cachedChildrenImpl();
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Test checks RuntimeException",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "remove",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "putDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        ), @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "flush",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "getChild",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void _testRuntimeException() throws IOException,
+            BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            fail();
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.setResult(MockAbstractPreferences.runtimeException);
+        try {
+            p.childrenNames();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.put("exceptionkey", "value");
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.absolutePath();
+        p.toString();
+        assertEquals("exception default", p.get("key", "exception default"));
+        try {
+            p.remove("key");
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.clear();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.putInt("key", 3);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getInt("key", 3);
+        try {
+            p.putLong("key", 3l);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getLong("key", 3l);
+        try {
+            p.putDouble("key", 3);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getDouble("key", 3);
+        try {
+            p.putBoolean("key", true);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getBoolean("key", true);
+        try {
+            p.putFloat("key", 3f);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getFloat("key", 3f);
+        try {
+            p.putByteArray("key", new byte[0]);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.getByteArray("key", new byte[0]);
+        try {
+            p.keys();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.keys();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.childrenNames();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.parent();
+        p.node("");
+        p.nodeExists("");
+        try {
+            p.removeNode();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.name();
+        p.absolutePath();
+        p.isUserNode();
+        MockPreferenceChangeListener pcl = new MockPreferenceChangeListener();
+        p.addPreferenceChangeListener(pcl);
+        p.removePreferenceChangeListener(pcl);
+        MockNodeChangeListener ncl = new MockNodeChangeListener();
+        p.addNodeChangeListener(ncl);
+        p.removeNodeChangeListener(ncl);
+        p.toString();
+        try {
+            p.sync();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.flush();
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.exportNode(new ByteArrayOutputStream());
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        try {
+            p.exportSubtree(new ByteArrayOutputStream());
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.isRemovedImpl();
+        try {
+            p.getChildImpl(null);
+            fail();
+        } catch (MockRuntimeException e) {
+        }
+        p.cachedChildrenImpl();
+    }
+
+@TestInfo(
+      level = TestLevel.TODO,
+      purpose = "Test is OK, but it verifies unspecified NullPointerException.",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "getChild",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        )
+    })
+    public void _testSPIReturnNull() throws IOException, BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            fail();
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.setResult(MockAbstractPreferences.returnNull);
+        try {
+            p.childrenNames();
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.absolutePath();
+        p.toString();
+        p.put("nullkey", "value");
+        assertEquals("null default", p.get("key", "null default"));
+        p.remove("key");
+        try {
+            p.clear();
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.putInt("key", 3);
+        p.getInt("key", 3);
+        p.putLong("key", 3l);
+        p.getLong("key", 3l);
+        p.putDouble("key", 3);
+        p.getDouble("key", 3);
+        p.putBoolean("key", true);
+        p.getBoolean("key", true);
+        p.putFloat("key", 3f);
+        p.getFloat("key", 3f);
+        p.putByteArray("key", new byte[0]);
+        p.getByteArray("key", new byte[0]);
+        p.keys();
+        try {
+            p.childrenNames();
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.parent();
+        p.node("");
+        p.nodeExists("");
+        try {
+            p.removeNode();
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.name();
+        p.absolutePath();
+        p.isUserNode();
+        MockPreferenceChangeListener mockPreferenceChangeListener = new MockPreferenceChangeListener();
+        p.addPreferenceChangeListener(mockPreferenceChangeListener);
+        p.removePreferenceChangeListener(mockPreferenceChangeListener);
+        MockNodeChangeListener mockNodeChangeListener = new MockNodeChangeListener();
+        p.addNodeChangeListener(mockNodeChangeListener);
+        p.removeNodeChangeListener(mockNodeChangeListener);
+        p.toString();
+        p.sync();
+        p.flush();
+        try {
+            p.exportNode(System.out);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.exportSubtree(System.out);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.isRemovedImpl();
+        try {
+            p.getChildImpl("");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        p.cachedChildrenImpl();
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Test verifies IllegalStateException",
+      targets = {
+        @TestTarget(
+          methodName = "nodeExists",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "remove",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "getInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "getLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "putDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        ), @TestTarget(
+          methodName = "getDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        ), @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "getBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "getFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "getByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "parent",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "node",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "addNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "removeNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "addPreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        ), @TestTarget(
+          methodName = "removePreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        ), @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "getChild",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void _testIllegalStateException() throws IOException,
+            BackingStoreException {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            fail();
+            return;
+        }
+        pref.removeNode();
+        // after remove node, every methods, except name(), absolutePath(),
+        // isUserNode(), flush() or nodeExists(""),
+        // will throw illegal state exception
+        pref.nodeExists("");
+        pref.name();
+        pref.absolutePath();
+        pref.isUserNode();
+        pref.toString();
+        pref.flush();
+        try {
+            pref.nodeExists("child");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.childrenNames();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.remove(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.clear();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.get("key", "null default");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.put("nullkey", "value");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putInt("key", 3);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getInt("key", 3);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putLong("key", 3l);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getLong("key", 3l);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putDouble("key", 3);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getDouble("key", 3);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putBoolean("key", true);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getBoolean("key", true);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putFloat("key", 3f);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getFloat("key", 3f);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.putByteArray("key", new byte[0]);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.getByteArray("key", new byte[0]);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.keys();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.keys();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.childrenNames();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.parent();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.node(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.removeNode();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref
+                    .addPreferenceChangeListener(new MockPreferenceChangeListener());
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref
+                    .removePreferenceChangeListener(new MockPreferenceChangeListener());
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.addNodeChangeListener(new MockNodeChangeListener());
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.removeNodeChangeListener(new MockNodeChangeListener());
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.sync();
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.exportNode(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.exportSubtree(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.isRemovedImpl();
+        p.cachedChildrenImpl();
+        try {
+            p.getChildImpl(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Test verifies NullPointerException & IllegalStateException",
+      targets = {
+        @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "getInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "getLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "getBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "getFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "getByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "addNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "removeNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "addPreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        ), @TestTarget(
+          methodName = "removePreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        )
+    })
+    public void _testNullAndIllegalStateException() throws Exception {
+        if (!(pref instanceof MockAbstractPreferences)) {
+            fail();
+            return;
+        }
+        MockAbstractPreferences p = (MockAbstractPreferences) pref;
+        p.removeNode();
+        try {
+            p.get(null, "null default");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.put(null, "value");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putInt(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getInt(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putLong(null, 3l);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getLong(null, 3l);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putDouble(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getDouble(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putBoolean(null, true);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getBoolean(null, true);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putFloat(null, 3f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getFloat(null, 3f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.putByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.getByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.addPreferenceChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.removePreferenceChangeListener(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            p.addNodeChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            p.removeNodeChangeListener(null);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
  
-	/**
-	 * @test java.util.prefs.AbstractPreferences#childrenNamesSpi()
-	 *
-	 */
-	public void testChildrenNamesSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		try {
-			assertEquals(0, p.childrenNamesSpi().length);
-		} catch(java.util.prefs.BackingStoreException bse) {
-			fail("java.util.prefs.BackingStoreException is thrown: " + 
-					bse.toString());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#childSpi()
-	 *
-	 */
-
-	public void testChildSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		Preferences child = p.node("mock1");
-		assertEquals(child, p.childSpi("mock1"));
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#flushSpi()
-	 *
-	 */
-
-	public void testFlushSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		try {
-			p.flushSpi();
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#getSpi()
-	 *
-	 */
-
-	public void testGetSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		try {
-			assertNull(p.getSpi(""));
-			p.put("key", "default");
-			assertEquals("default", p.getSpi("key"));
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#keysSpi()
-	 *
-	 */
-
-	public void testKeysSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		try {
-			p.put("key1", "default");
-			p.putInt("key2", 123);
-			assertEquals(2, p.keysSpi().length);
-			assertEquals("key2", p.keysSpi()[0]);
-			assertEquals("key1", p.keysSpi()[1]);
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#putSpi()
-	 *
-	 */
-
-	public void testPutSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		try {
-			p.putSpi("key1", "default");
-			p.putSpi("key2", "123");
-			assertEquals(2, p.keysSpi().length);
-			assertEquals("key2", p.keysSpi()[0]);
-			assertEquals("key1", p.keysSpi()[1]);
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#removeSpi()
-	 *
-	 */
-
-	public void testRemoveSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		p.put("key1", "value1");
-		try {
-			p.removeSpi("key1");
-
-			assertNull(p.getSpi("key1"));
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * @test java.util.prefs.AbstractPreferences#syncSpi()
-	 *
-	 */
-
-	public void testSyncSpi() {
-		MockAbstractPreferences p = new MockAbstractPreferences(
-				(AbstractPreferences) Preferences.userRoot(), "mock");
-		p.put("key1", "value1");
-		try {
-			p.syncSpi();
-		} catch(Exception e) {
-			fail("Unexpected exception was thrown: " + e.getMessage());
-		}
-	}
-	
-	/**
-	 * Regression for HARMONY-828
-	 */
-	public void testLongPath() throws Exception {
-		assertFalse(pref
-				.nodeExists("ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"));
-	}
+    /**
+     * @test java.util.prefs.AbstractPreferences#childrenNamesSpi()
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNamesSpi",
+          methodArgs = {}
+        )
+    })
+    public void testChildrenNamesSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        try {
+            assertEquals(0, p.childrenNamesSpi().length);
+        } catch(java.util.prefs.BackingStoreException bse) {
+            fail("java.util.prefs.BackingStoreException is thrown: " + 
+                    bse.toString());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#childSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "childSpi",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testChildSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        Preferences child = p.node("mock1");
+        assertEquals(child, p.childSpi("mock1"));
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#flushSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "flushSpi",
+          methodArgs = {}
+        )
+    })
+    public void testFlushSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        try {
+            p.flushSpi();
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#getSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "getSpi",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testGetSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        try {
+            assertNull(p.getSpi(""));
+            p.put("key", "default");
+            assertEquals("default", p.getSpi("key"));
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#keysSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "keysSpi",
+          methodArgs = {}
+        )
+    })
+    public void testKeysSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        try {
+            p.put("key1", "default");
+            p.putInt("key2", 123);
+            assertEquals(2, p.keysSpi().length);
+            assertEquals("key2", p.keysSpi()[0]);
+            assertEquals("key1", p.keysSpi()[1]);
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#putSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "putSpi",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testPutSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        try {
+            p.putSpi("key1", "default");
+            p.putSpi("key2", "123");
+            assertEquals(2, p.keysSpi().length);
+            assertEquals("key2", p.keysSpi()[0]);
+            assertEquals("key1", p.keysSpi()[1]);
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#removeSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "removeNodeSpi",
+          methodArgs = {}
+        )
+    })
+    public void testRemoveSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        p.put("key1", "value1");
+        try {
+            p.removeSpi("key1");
+
+            assertNull(p.getSpi("key1"));
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * @test java.util.prefs.AbstractPreferences#syncSpi()
+     *
+     */
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "syncSpi",
+          methodArgs = {}
+        )
+    })
+    public void testSyncSpi() {
+        MockAbstractPreferences p = new MockAbstractPreferences(
+                (AbstractPreferences) Preferences.userRoot(), "mock");
+        p.put("key1", "value1");
+        try {
+            p.syncSpi();
+        } catch(Exception e) {
+            fail("Unexpected exception was thrown: " + e.getMessage());
+        }
+    }
+    
+    /**
+     * Regression for HARMONY-828
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Regression test",
+      targets = {
+        @TestTarget(
+          methodName = "nodeExists",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testLongPath() throws Exception {
+        assertFalse(pref
+                .nodeExists("ddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"));
+    }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/BackingStoreExceptionTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/BackingStoreExceptionTest.java
index 5035a1b..c34853c 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/BackingStoreExceptionTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/BackingStoreExceptionTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.util.prefs.BackingStoreException;
 
 import junit.framework.TestCase;
@@ -26,11 +31,21 @@ import org.apache.harmony.testframework.serialization.SerializationTest;
  * 
  * 
  */
+@TestTargetClass(BackingStoreException.class)
 public class BackingStoreExceptionTest extends TestCase {
 
     /*
      * Class under test for void BackingStoreException(String)
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BackingStoreException",
+          methodArgs = {java.lang.String.class}
+        )
+    })
     public void testBackingStoreExceptionString() {
         BackingStoreException e = new BackingStoreException("msg");
         assertNull(e.getCause());
@@ -40,6 +55,15 @@ public class BackingStoreExceptionTest extends TestCase {
     /*
      * Class under test for void BackingStoreException(Throwable)
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "BackingStoreException",
+          methodArgs = {java.lang.Throwable.class}
+        )
+    })
     public void testBackingStoreExceptionThrowable() {
         Throwable t = new Throwable("msg");
         BackingStoreException e = new BackingStoreException(t);
@@ -51,6 +75,15 @@ public class BackingStoreExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization.
      */
+@TestInfo(
+          level = TestLevel.COMPLETE,
+          purpose = "Verifies serialization",
+          targets = {
+            @TestTarget(
+              methodName = "!SerializationSelf",
+              methodArgs = {}
+            )
+        })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new BackingStoreException("msg"));
@@ -59,6 +92,15 @@ public class BackingStoreExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+@TestInfo(
+          level = TestLevel.COMPLETE,
+          purpose = "Verifies serialization",
+          targets = {
+            @TestTarget(
+              methodName = "!SerializationGolden",
+              methodArgs = {}
+            )
+        })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this, new BackingStoreException("msg"));
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/FilePreferencesImplTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/FilePreferencesImplTest.java
index 026c813..2b641ab 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/FilePreferencesImplTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/FilePreferencesImplTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.FilePermission;
 import java.io.IOException;
 import java.security.Permission;
@@ -25,11 +30,12 @@ import java.util.prefs.Preferences;
 
 import junit.framework.TestCase;
 
+@TestTargetClass(java.util.prefs.Preferences.class)
 public class FilePreferencesImplTest extends TestCase {
 
     private String prevFactory;
-	private Preferences uroot;
-	private Preferences sroot;
+    private Preferences uroot;
+    private Preferences sroot;
     
     public FilePreferencesImplTest() {
         super();
@@ -39,7 +45,7 @@ public class FilePreferencesImplTest extends TestCase {
      //   prevFactory = System.getProperty("java.util.prefs.PreferencesFactory");
     //    System.setProperty("java.util.prefs.PreferencesFactory", "java.util.prefs.FilePreferencesFactoryImpl");
         
-	//	uroot = (AbstractPreferences) Preferences.userRoot();
+    //    uroot = (AbstractPreferences) Preferences.userRoot();
         uroot = Preferences.userRoot();
         sroot = Preferences.systemRoot();
     }
@@ -52,163 +58,208 @@ public class FilePreferencesImplTest extends TestCase {
         sroot = null;
     }
 
-	public void testPutGet() throws IOException, BackingStoreException {
-		uroot.put("ukey1", "value1");
-		assertEquals("value1", uroot.get("ukey1", null));
-		String[] names = uroot.keys();
-		assertTrue(names.length >= 1);
-
-		uroot.put("ukey2", "value3");
-		assertEquals("value3", uroot.get("ukey2", null));
-		uroot.put("\u4e2d key1", "\u4e2d value1");
-		assertEquals("\u4e2d value1", uroot.get("\u4e2d key1", null));
-		names = uroot.keys();
-		assertEquals(3, names.length);
-
-		uroot.clear();
-		names = uroot.keys();
-		assertEquals(0, names.length);
-
-		sroot.put("skey1", "value1");
-		assertEquals("value1", sroot.get("skey1", null));
-		sroot.put("\u4e2d key1", "\u4e2d value1");
-		assertEquals("\u4e2d value1", sroot.get("\u4e2d key1", null));
-	}
-
-	public void testChildNodes() throws Exception {
-		Preferences child1 = uroot.node("child1");
-		Preferences child2 = uroot.node("\u4e2d child2");
-		Preferences grandchild = child1.node("grand");
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Exceptions checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        )
+    })
+    public void testPutGet() throws IOException, BackingStoreException {
+        uroot.put("ukey1", "value1");
+        assertEquals("value1", uroot.get("ukey1", null));
+        String[] names = uroot.keys();
+        assertTrue(names.length >= 1);
+
+        uroot.put("ukey2", "value3");
+        assertEquals("value3", uroot.get("ukey2", null));
+        uroot.put("\u4e2d key1", "\u4e2d value1");
+        assertEquals("\u4e2d value1", uroot.get("\u4e2d key1", null));
+        names = uroot.keys();
+        assertEquals(3, names.length);
+
+        uroot.clear();
+        names = uroot.keys();
+        assertEquals(0, names.length);
+
+        sroot.put("skey1", "value1");
+        assertEquals("value1", sroot.get("skey1", null));
+        sroot.put("\u4e2d key1", "\u4e2d value1");
+        assertEquals("\u4e2d value1", sroot.get("\u4e2d key1", null));
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Exceptions checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        )
+    })
+    public void _testChildNodes() throws Exception {
+        Preferences child1 = uroot.node("child1");
+        Preferences child2 = uroot.node("\u4e2d child2");
+        Preferences grandchild = child1.node("grand");
         assertNotNull(grandchild);
 
-		String[] childNames = uroot.childrenNames();
-		assertEquals(4, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-
-		childNames = child1.childrenNames();
-		assertEquals(1, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-
-		childNames = child2.childrenNames();
-		assertEquals(0, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-
-		child1.removeNode();
-		childNames = uroot.childrenNames();
-		assertEquals(3, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-		// child2.removeNode();
-		// childNames = uroot.childrenNames();
-		// assertEquals(0, childNames.length);
-
-		child1 = sroot.node("child1");
-		child2 = sroot.node("child2");
-		grandchild = child1.node("grand");
-
-		childNames = sroot.childrenNames();
-
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-	//	assertEquals(2, childNames.length);
-
-		childNames = child1.childrenNames();
-		assertEquals(1, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-
-		childNames = child2.childrenNames();
-		assertEquals(0, childNames.length);
-		for (int i = 0; i < childNames.length; i++) {
-			System.out.println(childNames[i]);
-		}
-	}
-
-	public void testSecurityException() throws BackingStoreException {
-		Preferences child1 = uroot.node("child1");
-		MockFileSecurityManager manager = new MockFileSecurityManager();
-		manager.install();
-		try {
-			try {
-				uroot.node("securityNode");
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				// need FilePermission(delete);
-				child1.removeNode();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			try {
-				uroot.childrenNames();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			}
-			uroot.keys();
-			uroot.put("securitykey", "value1");
-			uroot.remove("securitykey");
-			try {
-				uroot.flush();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			} catch (BackingStoreException e) {
-				assertTrue(e.getCause() instanceof SecurityException);
-			}
-			try {
-				uroot.sync();
-				fail("should throw security exception");
-			} catch (SecurityException e) {
-			} catch (BackingStoreException e) {
-				assertTrue(e.getCause() instanceof SecurityException);
-			}
-		} finally {
-			manager.restoreDefault();
-		}
-	}
-
-	static class MockFileSecurityManager extends SecurityManager {
-
-		SecurityManager dflt;
-
-		public MockFileSecurityManager() {
-			super();
-			dflt = System.getSecurityManager();
-		}
-
-		public void install() {
-			System.setSecurityManager(this);
-		}
-
-		public void restoreDefault() {
-			System.setSecurityManager(dflt);
-		}
-
-		public void checkPermission(Permission perm) {
-			if (perm instanceof FilePermission) {
-				throw new SecurityException();
-			} else if (dflt != null) {
-				dflt.checkPermission(perm);
-			}
-		}
-
-		public void checkPermission(Permission perm, Object ctx) {
-			if (perm instanceof FilePermission) {
-				System.out.println(perm.getActions());
-				throw new SecurityException();
-			} else if (dflt != null) {
-				dflt.checkPermission(perm, ctx);
-			}
-		}
-
-	}
+        String[] childNames = uroot.childrenNames();
+        assertEquals(4, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+
+        childNames = child1.childrenNames();
+        assertEquals(1, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+
+        childNames = child2.childrenNames();
+        assertEquals(0, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+
+        child1.removeNode();
+        childNames = uroot.childrenNames();
+        assertEquals(3, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+        // child2.removeNode();
+        // childNames = uroot.childrenNames();
+        // assertEquals(0, childNames.length);
+
+        child1 = sroot.node("child1");
+        child2 = sroot.node("child2");
+        grandchild = child1.node("grand");
+
+        childNames = sroot.childrenNames();
+
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+    //    assertEquals(2, childNames.length);
+
+        childNames = child1.childrenNames();
+        assertEquals(1, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+
+        childNames = child2.childrenNames();
+        assertEquals(0, childNames.length);
+        for (int i = 0; i < childNames.length; i++) {
+            System.out.println(childNames[i]);
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "SecurityException checking only, but methods are abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "node",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "flush",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        )
+    })
+    public void testSecurityException() throws BackingStoreException {
+        Preferences child1 = uroot.node("child1");
+        MockFileSecurityManager manager = new MockFileSecurityManager();
+        manager.install();
+        try {
+            try {
+                uroot.node("securityNode");
+                fail("should throw security exception");
+            } catch (SecurityException e) {
+            }
+            try {
+                // need FilePermission(delete);
+                child1.removeNode();
+                fail("should throw security exception");
+            } catch (SecurityException e) {
+            }
+            try {
+                uroot.childrenNames();
+                fail("should throw security exception");
+            } catch (SecurityException e) {
+            }
+            uroot.keys();
+            uroot.put("securitykey", "value1");
+            uroot.remove("securitykey");
+            try {
+                uroot.flush();
+                fail("should throw security exception");
+            } catch (SecurityException e) {
+            } catch (BackingStoreException e) {
+                assertTrue(e.getCause() instanceof SecurityException);
+            }
+            try {
+                uroot.sync();
+                fail("should throw security exception");
+            } catch (SecurityException e) {
+            } catch (BackingStoreException e) {
+                assertTrue(e.getCause() instanceof SecurityException);
+            }
+        } finally {
+            manager.restoreDefault();
+        }
+    }
+
+    static class MockFileSecurityManager extends SecurityManager {
+
+        SecurityManager dflt;
+
+        public MockFileSecurityManager() {
+            super();
+            dflt = System.getSecurityManager();
+        }
+
+        public void install() {
+            System.setSecurityManager(this);
+        }
+
+        public void restoreDefault() {
+            System.setSecurityManager(dflt);
+        }
+
+        public void checkPermission(Permission perm) {
+            if (perm instanceof FilePermission) {
+                throw new SecurityException();
+            } else if (dflt != null) {
+                dflt.checkPermission(perm);
+            }
+        }
+
+        public void checkPermission(Permission perm, Object ctx) {
+            if (perm instanceof FilePermission) {
+                System.out.println(perm.getActions());
+                throw new SecurityException();
+            } else if (dflt != null) {
+                dflt.checkPermission(perm, ctx);
+            }
+        }
+
+    }
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/InvalidPreferencesFormatExceptionTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/InvalidPreferencesFormatExceptionTest.java
index 78ed704..39ef9f3 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/InvalidPreferencesFormatExceptionTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/InvalidPreferencesFormatExceptionTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.util.prefs.InvalidPreferencesFormatException;
 
 import junit.framework.TestCase;
@@ -25,11 +30,21 @@ import org.apache.harmony.testframework.serialization.SerializationTest;
 /**
  * 
  */
+@TestTargetClass(InvalidPreferencesFormatException.class)
 public class InvalidPreferencesFormatExceptionTest extends TestCase {
 
     /*
      * Class under test for void InvalidPreferencesFormatException(String)
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "InvalidPreferencesFormatException",
+          methodArgs = {java.lang.String.class}
+        )
+    })
     public void testInvalidPreferencesFormatExceptionString() {
         InvalidPreferencesFormatException e = new InvalidPreferencesFormatException(
                 "msg");
@@ -41,6 +56,15 @@ public class InvalidPreferencesFormatExceptionTest extends TestCase {
      * Class under test for void InvalidPreferencesFormatException(String,
      * Throwable)
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "InvalidPreferencesFormatException",
+          methodArgs = {java.lang.String.class, java.lang.Throwable.class}
+        )
+    })
     public void testInvalidPreferencesFormatExceptionStringThrowable() {
         Throwable t = new Throwable("root");
         InvalidPreferencesFormatException e = new InvalidPreferencesFormatException(
@@ -54,6 +78,15 @@ public class InvalidPreferencesFormatExceptionTest extends TestCase {
     /*
      * Class under test for void InvalidPreferencesFormatException(Throwable)
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "InvalidPreferencesFormatException",
+          methodArgs = {java.lang.Throwable.class}
+        )
+    })
     public void testInvalidPreferencesFormatExceptionThrowable() {
         Throwable t = new Throwable("root");
         InvalidPreferencesFormatException e = new InvalidPreferencesFormatException(
@@ -66,6 +99,15 @@ public class InvalidPreferencesFormatExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization.
      */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Verifies serialization",
+      targets = {
+        @TestTarget(
+          methodName = "!SerializationSelf",
+          methodArgs = {}
+        )
+    })
     public void testSerializationSelf() throws Exception {
 
         SerializationTest.verifySelf(new InvalidPreferencesFormatException(
@@ -75,6 +117,15 @@ public class InvalidPreferencesFormatExceptionTest extends TestCase {
     /**
      * @tests serialization/deserialization compatibility with RI.
      */
+@TestInfo(
+          level = TestLevel.COMPLETE,
+          purpose = "Verifies serialization",
+          targets = {
+            @TestTarget(
+              methodName = "!SerializationGolden",
+              methodArgs = {}
+            )
+        })
     public void testSerializationCompatibility() throws Exception {
 
         SerializationTest.verifyGolden(this,
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockAbstractPreferences.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockAbstractPreferences.java
index 5faca23..1820954 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockAbstractPreferences.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockAbstractPreferences.java
@@ -24,222 +24,222 @@ import java.util.prefs.AbstractPreferences;
 import java.util.prefs.BackingStoreException;
 
 public class MockAbstractPreferences extends AbstractPreferences {
-	static final int NORMAL = 0;
-
-	static final int backingException = 1;
-
-	static final int runtimeException = 2;
-
-	static final int returnNull = 3;
-
-	int result = NORMAL;
-
-	Properties attr = new Properties();
-
-	Map<String, MockAbstractPreferences> childs = new HashMap<String, MockAbstractPreferences>();
-
-	private int flushedTimes;
-
-	private int syncTimes;
-
-	protected MockAbstractPreferences(AbstractPreferences parent, String name) {
-		this(parent, name, false);
-
-	}
-
-	protected MockAbstractPreferences(AbstractPreferences parent, String name,
-			boolean newNode) {
-		super(parent, name);
-		super.newNode = newNode;
-		if (parent instanceof MockAbstractPreferences) {
-			((MockAbstractPreferences) parent).addChild(this);
-		}
-	}
-
-	public int getFlushedTimes() {
-		return flushedTimes;
-	}
-
-	public void resetFlushedTimes() {
-		flushedTimes = 0;
-	}
-
-	public int getSyncTimes() {
-		return syncTimes;
-	}
-
-	public void resetSyncTimes() {
-		syncTimes = 0;
-	}
-
-	private void addChild(MockAbstractPreferences c) {
-		childs.put(c.name(), c);
-	}
-
-	public void setResult(int r) {
-		result = r;
-	}
-
-	public Object lock() {
-		return lock;
-	}
-
-	public String[] childrenNamesSpi() throws BackingStoreException {
-		checkException();
-		if (result == returnNull)
-			return null;
-		String[] r = new String[childs.size()];
-		childs.keySet().toArray(r);
-		return r;
-	}
-
-	private void checkException() throws BackingStoreException {
-		switch (result) {
-		case NORMAL:
-			return;
-		case backingException:
-			throw new BackingStoreException("test");
-		case runtimeException:
-			throw new MockRuntimeException("test");
-		}
-	}
-
-	public AbstractPreferences publicChildSpi(String name) {
-		return childSpi(name);
-	}
-
-	public AbstractPreferences childSpi(String name) {
-		try {
-			checkException();
-		} catch (BackingStoreException e) {
-		}
-		if (result == returnNull)
-			return null;
-		AbstractPreferences r = childs.get(name);
-		if (r == null) {
-			r = new MockAbstractPreferences(this, name, true);
-
-		}
-		return r;
-	}
-
-	public void flushSpi() throws BackingStoreException {
-		checkException();
-		flushedTimes++;
-	}
-
-	public String getSpi(String key) {
-		try {
-			checkException();
-		} catch (BackingStoreException e) {
-		}
-		if (null == key) {
-			return null;
-		}
-		return result == returnNull ? null : attr.getProperty(key);
-	}
-
-	public String[] keysSpi() throws BackingStoreException {
-		checkException();
-		Set<Object> keys = attr.keySet();
-		String[] results = new String[keys.size()];
-		keys.toArray(results);
-		return result == returnNull ? null : results;
-	}
-
-	public void putSpi(String name, String value) {
-		try {
-			checkException();
-		} catch (BackingStoreException e) {
-		}
-		if (name == null || value == null) {
-			return;
-		}
-		attr.put(name, value);
-	}
-
-	protected void removeNodeSpi() throws BackingStoreException {
-		checkException();
-		((MockAbstractPreferences) parent()).childs.remove(name());
-	}
-
-	public void removeSpi(String key) {
-		try {
-			checkException();
-		} catch (BackingStoreException e) {
-		}
-		if (null == key) {
-			return;
-		}
-		attr.remove(key);
-	}
-
-	public void syncSpi() throws BackingStoreException {
-		checkException();
-		syncTimes++;
-	}
-
-	public boolean getNewNode() {
-		return newNode;
-	}
-
-	public Object getLock() {
-		return lock;
-	}
-
-	public void protectedAbstractMethod() {
-		try {
-			childrenNamesSpi();
-		} catch (BackingStoreException e) {
-		}
-		childSpi("mock");
-		try {
-			flushSpi();
-		} catch (BackingStoreException e1) {
-		}
-		getSpi(null);
-		isRemoved();
-		try {
-			keysSpi();
-		} catch (BackingStoreException e2) {
-		}
-		putSpi(null, null);
-		try {
-			removeNodeSpi();
-		} catch (BackingStoreException e3) {
-		}
-		removeSpi(null);
-		try {
-			syncSpi();
-		} catch (BackingStoreException e4) {
-		}
-	}
-
-	public boolean isRemovedImpl() {
-		return super.isRemoved();
-	}
-
-	public AbstractPreferences getChildImpl(String name)
-			throws BackingStoreException {
-		return super.getChild(name);
-	}
-
-	public AbstractPreferences[] cachedChildrenImpl() {
-		return super.cachedChildren();
-	}
+    static final int NORMAL = 0;
+
+    static final int backingException = 1;
+
+    static final int runtimeException = 2;
+
+    static final int returnNull = 3;
+
+    int result = NORMAL;
+
+    Properties attr = new Properties();
+
+    Map<String, MockAbstractPreferences> childs = new HashMap<String, MockAbstractPreferences>();
+
+    private int flushedTimes;
+
+    private int syncTimes;
+
+    protected MockAbstractPreferences(AbstractPreferences parent, String name) {
+        this(parent, name, false);
+
+    }
+
+    protected MockAbstractPreferences(AbstractPreferences parent, String name,
+            boolean newNode) {
+        super(parent, name);
+        super.newNode = newNode;
+        if (parent instanceof MockAbstractPreferences) {
+            ((MockAbstractPreferences) parent).addChild(this);
+        }
+    }
+
+    public int getFlushedTimes() {
+        return flushedTimes;
+    }
+
+    public void resetFlushedTimes() {
+        flushedTimes = 0;
+    }
+
+    public int getSyncTimes() {
+        return syncTimes;
+    }
+
+    public void resetSyncTimes() {
+        syncTimes = 0;
+    }
+
+    private void addChild(MockAbstractPreferences c) {
+        childs.put(c.name(), c);
+    }
+
+    public void setResult(int r) {
+        result = r;
+    }
+
+    public Object lock() {
+        return lock;
+    }
+
+    public String[] childrenNamesSpi() throws BackingStoreException {
+        checkException();
+        if (result == returnNull)
+            return null;
+        String[] r = new String[childs.size()];
+        childs.keySet().toArray(r);
+        return r;
+    }
+
+    private void checkException() throws BackingStoreException {
+        switch (result) {
+        case NORMAL:
+            return;
+        case backingException:
+            throw new BackingStoreException("test");
+        case runtimeException:
+            throw new MockRuntimeException("test");
+        }
+    }
+
+    public AbstractPreferences publicChildSpi(String name) {
+        return childSpi(name);
+    }
+
+    public AbstractPreferences childSpi(String name) {
+        try {
+            checkException();
+        } catch (BackingStoreException e) {
+        }
+        if (result == returnNull)
+            return null;
+        AbstractPreferences r = childs.get(name);
+        if (r == null) {
+            r = new MockAbstractPreferences(this, name, true);
+
+        }
+        return r;
+    }
+
+    public void flushSpi() throws BackingStoreException {
+        checkException();
+        flushedTimes++;
+    }
+
+    public String getSpi(String key) {
+        try {
+            checkException();
+        } catch (BackingStoreException e) {
+        }
+        if (null == key) {
+            return null;
+        }
+        return result == returnNull ? null : attr.getProperty(key);
+    }
+
+    public String[] keysSpi() throws BackingStoreException {
+        checkException();
+        Set<Object> keys = attr.keySet();
+        String[] results = new String[keys.size()];
+        keys.toArray(results);
+        return result == returnNull ? null : results;
+    }
+
+    public void putSpi(String name, String value) {
+        try {
+            checkException();
+        } catch (BackingStoreException e) {
+        }
+        if (name == null || value == null) {
+            return;
+        }
+        attr.put(name, value);
+    }
+
+    protected void removeNodeSpi() throws BackingStoreException {
+        checkException();
+        ((MockAbstractPreferences) parent()).childs.remove(name());
+    }
+
+    public void removeSpi(String key) {
+        try {
+            checkException();
+        } catch (BackingStoreException e) {
+        }
+        if (null == key) {
+            return;
+        }
+        attr.remove(key);
+    }
+
+    public void syncSpi() throws BackingStoreException {
+        checkException();
+        syncTimes++;
+    }
+
+    public boolean getNewNode() {
+        return newNode;
+    }
+
+    public Object getLock() {
+        return lock;
+    }
+
+    public void protectedAbstractMethod() {
+        try {
+            childrenNamesSpi();
+        } catch (BackingStoreException e) {
+        }
+        childSpi("mock");
+        try {
+            flushSpi();
+        } catch (BackingStoreException e1) {
+        }
+        getSpi(null);
+        isRemoved();
+        try {
+            keysSpi();
+        } catch (BackingStoreException e2) {
+        }
+        putSpi(null, null);
+        try {
+            removeNodeSpi();
+        } catch (BackingStoreException e3) {
+        }
+        removeSpi(null);
+        try {
+            syncSpi();
+        } catch (BackingStoreException e4) {
+        }
+    }
+
+    public boolean isRemovedImpl() {
+        return super.isRemoved();
+    }
+
+    public AbstractPreferences getChildImpl(String name)
+            throws BackingStoreException {
+        return super.getChild(name);
+    }
+
+    public AbstractPreferences[] cachedChildrenImpl() {
+        return super.cachedChildren();
+    }
 
 }
 
 class MockRuntimeException extends RuntimeException {
 
-	private static final long serialVersionUID = 1L;
+    private static final long serialVersionUID = 1L;
 
-	public MockRuntimeException(String s) {
-		super(s);
-	}
+    public MockRuntimeException(String s) {
+        super(s);
+    }
 
-	public MockRuntimeException() {
-		super();
-	}
+    public MockRuntimeException() {
+        super();
+    }
 }
 
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockNodeChangeListener.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockNodeChangeListener.java
index 7fba914..4902343 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockNodeChangeListener.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockNodeChangeListener.java
@@ -5,161 +5,161 @@ import java.util.prefs.NodeChangeListener;
 import java.util.prefs.Preferences;
 
 public class MockNodeChangeListener implements NodeChangeListener {
-	private boolean addDispatched = false;
-
-	private boolean removeDispatched = false;
-
-	private Object addLock = new Object();
-
-	private Object removeLock = new Object();
-
-	private int added = 0;
-
-	private int removed = 0;
-
-	private int testNum = 0;
-
-	public static final int TEST_GET_CHILD = 1;
-
-	public static final int TEST_GET_PARENT = 2;
-
-	boolean addResult = false;
-
-	boolean removeResult = false;
-
-	public MockNodeChangeListener(int test) {
-		testNum = test;
-	}
-
-	public MockNodeChangeListener() {
-
-	}
-
-	public void childAdded(NodeChangeEvent e) {
-
-		synchronized (addLock) {
-			switch (testNum) {
-			case TEST_GET_CHILD:
-				Preferences child = e.getChild();
-				if (child == null) {
-					addResult = false;
-				} else {
-					if (child.name() == "mock1") {
-						addResult = true;
-					}
-				}
-				break;
-			case TEST_GET_PARENT:
-				Preferences parent = e.getParent();
-				if (parent == null) {
-					addResult = false;
-				} else {
-					if (parent.name() == "mock") {
-						addResult = true;
-					}
-				}
-
-				break;
-			}
-			++added;
-			addDispatched = true;
-			addLock.notifyAll();
-		}
-	}
-
-	public void childRemoved(NodeChangeEvent e) {
-		synchronized (removeLock) {
-			switch (testNum) {
-			case TEST_GET_CHILD:
-				Preferences child = e.getChild();
-				if (child == null) {
-					removeResult = false;
-				} else {
-					if (child.name() == "mock1") {
-						removeResult = true;
-					}
-				}
-				break;
-			case TEST_GET_PARENT:
-				Preferences parent = e.getParent();
-				if (parent == null) {
-					addResult = false;
-				} else {
-					if (parent.name() == "mock") {
-						addResult = true;
-					}
-				}
-
-				break;
-			}
-			removed++;
-			removeDispatched = true;
-			removeLock.notifyAll();
-		}
-	}
-
-	public boolean getAddResult() {
-		synchronized (addLock) {
-			if (!addDispatched) {
-				try {
-					// TODO: don't know why must add limitation
-					addLock.wait(100);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			addDispatched = false;
-		}
-		return addResult;
-	}
-
-	public boolean getRemoveResult() {
-		synchronized (removeLock) {
-			if (!removeDispatched) {
-				try {
-					// TODO: don't know why must add limitation
-					removeLock.wait(100);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			removeDispatched = false;
-		}
-		return removeResult;
-	}
-
-	public int getAdded() {
-		synchronized (addLock) {
-			if (!addDispatched) {
-				try {
-					// TODO: don't know why must add limitation
-					addLock.wait(1000);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			addDispatched = false;
-		}
-		return added;
-	}
-
-	public int getRemoved() {
-		synchronized (removeLock) {
-			if (!removeDispatched) {
-				try {
-					removeLock.wait(1000);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			removeDispatched = false;
-		}
-		return removed;
-
-	}
-
-	public void reset() {
-		added = 0;
-		removed = 0;
-	}
+    private boolean addDispatched = false;
+
+    private boolean removeDispatched = false;
+
+    private Object addLock = new Object();
+
+    private Object removeLock = new Object();
+
+    private int added = 0;
+
+    private int removed = 0;
+
+    private int testNum = 0;
+
+    public static final int TEST_GET_CHILD = 1;
+
+    public static final int TEST_GET_PARENT = 2;
+
+    boolean addResult = false;
+
+    boolean removeResult = false;
+
+    public MockNodeChangeListener(int test) {
+        testNum = test;
+    }
+
+    public MockNodeChangeListener() {
+
+    }
+
+    public void childAdded(NodeChangeEvent e) {
+
+        synchronized (addLock) {
+            switch (testNum) {
+            case TEST_GET_CHILD:
+                Preferences child = e.getChild();
+                if (child == null) {
+                    addResult = false;
+                } else {
+                    if (child.name() == "mock1") {
+                        addResult = true;
+                    }
+                }
+                break;
+            case TEST_GET_PARENT:
+                Preferences parent = e.getParent();
+                if (parent == null) {
+                    addResult = false;
+                } else {
+                    if (parent.name() == "mock") {
+                        addResult = true;
+                    }
+                }
+
+                break;
+            }
+            ++added;
+            addDispatched = true;
+            addLock.notifyAll();
+        }
+    }
+
+    public void childRemoved(NodeChangeEvent e) {
+        synchronized (removeLock) {
+            switch (testNum) {
+            case TEST_GET_CHILD:
+                Preferences child = e.getChild();
+                if (child == null) {
+                    removeResult = false;
+                } else {
+                    if (child.name() == "mock1") {
+                        removeResult = true;
+                    }
+                }
+                break;
+            case TEST_GET_PARENT:
+                Preferences parent = e.getParent();
+                if (parent == null) {
+                    addResult = false;
+                } else {
+                    if (parent.name() == "mock") {
+                        addResult = true;
+                    }
+                }
+
+                break;
+            }
+            removed++;
+            removeDispatched = true;
+            removeLock.notifyAll();
+        }
+    }
+
+    public boolean getAddResult() {
+        synchronized (addLock) {
+            if (!addDispatched) {
+                try {
+                    // TODO: don't know why must add limitation
+                    addLock.wait(100);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            addDispatched = false;
+        }
+        return addResult;
+    }
+
+    public boolean getRemoveResult() {
+        synchronized (removeLock) {
+            if (!removeDispatched) {
+                try {
+                    // TODO: don't know why must add limitation
+                    removeLock.wait(100);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            removeDispatched = false;
+        }
+        return removeResult;
+    }
+
+    public int getAdded() {
+        synchronized (addLock) {
+            if (!addDispatched) {
+                try {
+                    // TODO: don't know why must add limitation
+                    addLock.wait(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            addDispatched = false;
+        }
+        return added;
+    }
+
+    public int getRemoved() {
+        synchronized (removeLock) {
+            if (!removeDispatched) {
+                try {
+                    removeLock.wait(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            removeDispatched = false;
+        }
+        return removed;
+
+    }
+
+    public void reset() {
+        added = 0;
+        removed = 0;
+    }
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferenceChangeListener.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferenceChangeListener.java
index b09383e..0e62daf 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferenceChangeListener.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferenceChangeListener.java
@@ -4,99 +4,99 @@ import java.util.prefs.PreferenceChangeEvent;
 import java.util.prefs.PreferenceChangeListener;
 
 public class MockPreferenceChangeListener implements PreferenceChangeListener {
-	private Object lock = new Object();
+    private Object lock = new Object();
 
-	private int changed = 0;
+    private int changed = 0;
 
-	private boolean addDispatched = false;
-	
-	public static final int TEST_GET_KEY = 1;
+    private boolean addDispatched = false;
+    
+    public static final int TEST_GET_KEY = 1;
 
-	public static final int TEST_GET_NEW_VALUE = 2;
-	
-	public static final int TEST_GET_NODE = 3;
-	
-	boolean result = false;
-	
-	int testNum = 0;
-	
-	
-	public MockPreferenceChangeListener() {
-		
-	}
-	
-	public MockPreferenceChangeListener(int test) {
-		testNum = test;
-	}
+    public static final int TEST_GET_NEW_VALUE = 2;
+    
+    public static final int TEST_GET_NODE = 3;
+    
+    boolean result = false;
+    
+    int testNum = 0;
+    
+    
+    public MockPreferenceChangeListener() {
+        
+    }
+    
+    public MockPreferenceChangeListener(int test) {
+        testNum = test;
+    }
 
-	// private Object lock = new Object();
+    // private Object lock = new Object();
 
-	public void preferenceChange(PreferenceChangeEvent pce) {
-		synchronized (lock) {
-			switch(testNum) {
-				case TEST_GET_KEY:
-					if(pce != null) {
-						if(pce.getKey().equals("key_int")) {
-							result = true;
-						}
-					} 
-					break;
-				case TEST_GET_NEW_VALUE:
-					if(pce != null) {
-						if(pce.getNewValue().equals(new Integer(Integer.MAX_VALUE).toString())) {
-							result = true;
-						}
-					} 					
-					break;
-				case TEST_GET_NODE:
-					if(pce != null) {
-						if("mock".equals(pce.getNode().name())) {
-							result = true;
-						}
-					} 					
-	
-					break;
-			}
-			changed++;
-			addDispatched = true;
-			lock.notifyAll();
-		}
-	}
+    public void preferenceChange(PreferenceChangeEvent pce) {
+        synchronized (lock) {
+            switch(testNum) {
+                case TEST_GET_KEY:
+                    if(pce != null) {
+                        if(pce.getKey().equals("key_int")) {
+                            result = true;
+                        }
+                    } 
+                    break;
+                case TEST_GET_NEW_VALUE:
+                    if(pce != null) {
+                        if(pce.getNewValue().equals(new Integer(Integer.MAX_VALUE).toString())) {
+                            result = true;
+                        }
+                    }                     
+                    break;
+                case TEST_GET_NODE:
+                    if(pce != null) {
+                        if("mock".equals(pce.getNode().name())) {
+                            result = true;
+                        }
+                    }                     
+    
+                    break;
+            }
+            changed++;
+            addDispatched = true;
+            lock.notifyAll();
+        }
+    }
 
-	public boolean getResult() {
-		synchronized (lock) {
+    public boolean getResult() {
+        synchronized (lock) {
 
-			if (!addDispatched) {
-				try {
-					// TODO: don't know why must add limitation
-					lock.wait(100);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			addDispatched = false;
-			return result;
-		}
-	}
-	
-	public int getChanged() {
-		synchronized (lock) {
+            if (!addDispatched) {
+                try {
+                    // TODO: don't know why must add limitation
+                    lock.wait(100);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            addDispatched = false;
+            return result;
+        }
+    }
+    
+    public int getChanged() {
+        synchronized (lock) {
 
-			if (!addDispatched) {
-				try {
-					// TODO: don't know why must add limitation
-					lock.wait(1000);
-				} catch (InterruptedException e) {
-					e.printStackTrace();
-				}
-			}
-			addDispatched = false;
-			return changed;
-		}
-	}
+            if (!addDispatched) {
+                try {
+                    // TODO: don't know why must add limitation
+                    lock.wait(1000);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+            }
+            addDispatched = false;
+            return changed;
+        }
+    }
 
-	public void reset() {
-		changed = 0;
-		result = false;
-	}
+    public void reset() {
+        changed = 0;
+        result = false;
+    }
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferencesFactory.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferencesFactory.java
index 08b43ec..37db55d 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferencesFactory.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockPreferencesFactory.java
@@ -23,20 +23,20 @@ import java.util.prefs.PreferencesFactory;
  * 
  */
 public class MockPreferencesFactory implements PreferencesFactory {
-	static MockAbstractPreferences userRoot = new MockAbstractPreferences(null,
-			"");
+    static MockAbstractPreferences userRoot = new MockAbstractPreferences(null,
+            "");
 
-	static MockAbstractPreferences systemRoot = new MockAbstractPreferences(
-			null, "");
+    static MockAbstractPreferences systemRoot = new MockAbstractPreferences(
+            null, "");
 
-	public MockPreferencesFactory() {
-	}
+    public MockPreferencesFactory() {
+    }
 
-	public Preferences userRoot() {
-		return userRoot;
-	}
+    public Preferences userRoot() {
+        return userRoot;
+    }
 
-	public Preferences systemRoot() {
-		return systemRoot;
-	}
+    public Preferences systemRoot() {
+        return systemRoot;
+    }
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockSecurityManager.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockSecurityManager.java
index 27f9a97..e5a0bfd 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockSecurityManager.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/MockSecurityManager.java
@@ -24,37 +24,37 @@ import java.security.Permission;
  */
 class MockSecurityManager extends SecurityManager {
 
-	SecurityManager dflt;
-
-	public MockSecurityManager() {
-		super();
-		dflt = System.getSecurityManager();
-	}
-
-	public void install() {
-		System.setSecurityManager(this);
-	}
-
-	public void restoreDefault() {
-		System.setSecurityManager(dflt);
-	}
-
-	public void checkPermission(Permission perm) {
-		if (perm instanceof RuntimePermission
-				&& perm.getName().equals("preferences")) {
-			throw new SecurityException();
-		} else if (dflt != null) {
-			dflt.checkPermission(perm);
-		}
-	}
-
-	public void checkPermission(Permission perm, Object ctx) {
-		if (perm instanceof RuntimePermission
-				&& perm.getName().equals("preferences")) {
-			throw new SecurityException();
-		} else if (dflt != null) {
-			dflt.checkPermission(perm, ctx);
-		}
-	}
+    SecurityManager dflt;
+
+    public MockSecurityManager() {
+        super();
+        dflt = System.getSecurityManager();
+    }
+
+    public void install() {
+        System.setSecurityManager(this);
+    }
+
+    public void restoreDefault() {
+        System.setSecurityManager(dflt);
+    }
+
+    public void checkPermission(Permission perm) {
+        if (perm instanceof RuntimePermission
+                && perm.getName().equals("preferences")) {
+            throw new SecurityException();
+        } else if (dflt != null) {
+            dflt.checkPermission(perm);
+        }
+    }
+
+    public void checkPermission(Permission perm, Object ctx) {
+        if (perm instanceof RuntimePermission
+                && perm.getName().equals("preferences")) {
+            throw new SecurityException();
+        } else if (dflt != null) {
+            dflt.checkPermission(perm, ctx);
+        }
+    }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeEventTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeEventTest.java
index 79835ba..b565924 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeEventTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeEventTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.NotSerializableException;
 import java.util.prefs.AbstractPreferences;
 import java.util.prefs.BackingStoreException;
@@ -29,87 +34,133 @@ import org.apache.harmony.testframework.serialization.SerializationTest;
 /**
  * 
  */
+@TestTargetClass(NodeChangeEvent.class)
 public class NodeChangeEventTest extends TestCase {
 
-	NodeChangeEvent event;
-
-	public void testConstructor() {
-		event = new NodeChangeEvent(Preferences.systemRoot(), Preferences
-				.userRoot());
-		assertSame(Preferences.systemRoot(), event.getParent());
-		assertSame(Preferences.userRoot(), event.getChild());
-		assertSame(Preferences.systemRoot(), event.getSource());
-	}
-
-	public void testConstructorNullParam() {
-		try {
-			event = new NodeChangeEvent(null, Preferences.userRoot());
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		event = new NodeChangeEvent(Preferences.systemRoot(), null);
-		assertSame(Preferences.systemRoot(), event.getParent());
-		assertNull(event.getChild());
-		assertSame(Preferences.systemRoot(), event.getSource());
-	}
-
-	public void testSerialization() throws Exception {
-
-		event = new NodeChangeEvent(Preferences.systemRoot(), null);
-
-		try {
-			SerializationTest.copySerializable(event);
-			fail("No expected NotSerializableException");
-		} catch (NotSerializableException e) {
-		}
-	}
-
-	public void testGetChild() throws BackingStoreException {
-
-		AbstractPreferences parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-
-		AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
-
-		MockNodeChangeListener nl = new MockNodeChangeListener(
-				MockNodeChangeListener.TEST_GET_CHILD);
-		try {
-			pref.addNodeChangeListener(nl);
-			Preferences child1 = pref.node("mock1");
-			assertEquals(1, nl.getAdded());
-			assertTrue(nl.getAddResult());
-			nl.reset();
-			child1.removeNode();
-			assertEquals(1, nl.getRemoved());
-			assertTrue(nl.getRemoveResult());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-		}
-	}
-	
-	public void testGetParent() throws BackingStoreException {
-
-		AbstractPreferences parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-
-		AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
-
-		MockNodeChangeListener nl = new MockNodeChangeListener(
-				MockNodeChangeListener.TEST_GET_CHILD);
-		try {
-			pref.addNodeChangeListener(nl);
-			Preferences child1 = pref.node("mock1");
-			assertEquals(1, nl.getAdded());
-			assertTrue(nl.getAddResult());
-			nl.reset();
-			child1.removeNode();
-			assertEquals(1, nl.getRemoved());
-			assertTrue(nl.getRemoveResult());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-		}
-	}
+    NodeChangeEvent event;
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "NodeChangeEvent",
+          methodArgs = {java.util.prefs.Preferences.class, java.util.prefs.Preferences.class}
+        )
+    })
+    public void testConstructor() {
+        event = new NodeChangeEvent(Preferences.systemRoot(), Preferences
+                .userRoot());
+        assertSame(Preferences.systemRoot(), event.getParent());
+        assertSame(Preferences.userRoot(), event.getChild());
+        assertSame(Preferences.systemRoot(), event.getSource());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "NodeChangeEvent",
+          methodArgs = {java.util.prefs.Preferences.class, java.util.prefs.Preferences.class}
+        )
+    })
+    public void testConstructorNullParam() {
+        try {
+            event = new NodeChangeEvent(null, Preferences.userRoot());
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        event = new NodeChangeEvent(Preferences.systemRoot(), null);
+        assertSame(Preferences.systemRoot(), event.getParent());
+        assertNull(event.getChild());
+        assertSame(Preferences.systemRoot(), event.getSource());
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Verifies serialization",
+      targets = {
+        @TestTarget(
+          methodName = "!Serialization",
+          methodArgs = {}
+        )
+    })
+    public void testSerialization() throws Exception {
+
+        event = new NodeChangeEvent(Preferences.systemRoot(), null);
+
+        try {
+            SerializationTest.copySerializable(event);
+            fail("No expected NotSerializableException");
+        } catch (NotSerializableException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test is correct, functionality checked in separate Mock class.",
+      targets = {
+        @TestTarget(
+          methodName = "getChild",
+          methodArgs = {}
+        )
+    })
+    public void testGetChild() throws BackingStoreException {
+
+        AbstractPreferences parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+
+        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
+
+        MockNodeChangeListener nl = new MockNodeChangeListener(
+                MockNodeChangeListener.TEST_GET_CHILD);
+        try {
+            pref.addNodeChangeListener(nl);
+            Preferences child1 = pref.node("mock1");
+            assertEquals(1, nl.getAdded());
+            assertTrue(nl.getAddResult());
+            nl.reset();
+            child1.removeNode();
+            assertEquals(1, nl.getRemoved());
+            assertTrue(nl.getRemoveResult());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+        }
+    }
+    
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test is correct, functionality checked in separate Mock class.",
+      targets = {
+        @TestTarget(
+          methodName = "getParent",
+          methodArgs = {}
+        )
+    })
+    public void testGetParent() throws BackingStoreException {
+
+        AbstractPreferences parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+
+        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
+
+        MockNodeChangeListener nl = new MockNodeChangeListener(
+                MockNodeChangeListener.TEST_GET_CHILD);
+        try {
+            pref.addNodeChangeListener(nl);
+            Preferences child1 = pref.node("mock1");
+            assertEquals(1, nl.getAdded());
+            assertTrue(nl.getAddResult());
+            nl.reset();
+            child1.removeNode();
+            assertEquals(1, nl.getRemoved());
+            assertTrue(nl.getRemoveResult());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+        }
+    }
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeListenerTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeListenerTest.java
index 509fa9e..5ef4f50 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeListenerTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/NodeChangeListenerTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.util.prefs.NodeChangeEvent;
 import java.util.prefs.NodeChangeListener;
 import java.util.prefs.Preferences;
@@ -25,43 +30,62 @@ import junit.framework.TestCase;
 /**
  * 
  */
+@TestTargetClass(NodeChangeListener.class)
 public class NodeChangeListenerTest extends TestCase {
 
-	NodeChangeListener l;
+    NodeChangeListener l;
 
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		l = new NodeChangeListenerImpl();
-	}
+    /*
+     * @see TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        l = new NodeChangeListenerImpl();
+    }
 
-	/*
-	 * @see TestCase#tearDown()
-	 */
-	protected void tearDown() throws Exception {
-		super.tearDown();
-	}
+    /*
+     * @see TestCase#tearDown()
+     */
+    protected void tearDown() throws Exception {
+        super.tearDown();
+    }
 
-	public void testChildAdded() {
-		l.childAdded(new NodeChangeEvent(Preferences.userRoot(), Preferences
-				.userRoot()));
-	}
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Testing Interface",
+      targets = {
+        @TestTarget(
+          methodName = "childAdded",
+          methodArgs = {java.util.prefs.NodeChangeEvent.class}
+        )
+    })
+    public void testChildAdded() {
+        l.childAdded(new NodeChangeEvent(Preferences.userRoot(), Preferences
+                .userRoot()));
+    }
 
-	public void testChildRemoved() {
-		l.childRemoved(new NodeChangeEvent(Preferences.userRoot(), Preferences
-				.userRoot()));
-	}
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Testing Interface",
+      targets = {
+        @TestTarget(
+          methodName = "childRemoved",
+          methodArgs = {java.util.prefs.NodeChangeEvent.class}
+        )
+    })
+    public void testChildRemoved() {
+        l.childRemoved(new NodeChangeEvent(Preferences.userRoot(), Preferences
+                .userRoot()));
+    }
 
-	public static class NodeChangeListenerImpl implements NodeChangeListener {
+    public static class NodeChangeListenerImpl implements NodeChangeListener {
 
-		public void childAdded(NodeChangeEvent e) {
-		}
+        public void childAdded(NodeChangeEvent e) {
+        }
 
-		public void childRemoved(NodeChangeEvent e) {
-		}
+        public void childRemoved(NodeChangeEvent e) {
+        }
 
-	}
+    }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeEventTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeEventTest.java
index c3709dc..267ac28 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeEventTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeEventTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.NotSerializableException;
 import java.util.prefs.AbstractPreferences;
 import java.util.prefs.PreferenceChangeEvent;
@@ -28,10 +33,20 @@ import org.apache.harmony.testframework.serialization.SerializationTest;
 /**
  * 
  */
+@TestTargetClass(PreferenceChangeEvent.class)
 public class PreferenceChangeEventTest extends TestCase {
 
     PreferenceChangeEvent event;
 
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Checks exception.",
+      targets = {
+        @TestTarget(
+          methodName = "PreferenceChangeEvent",
+          methodArgs = {java.util.prefs.Preferences.class, java.lang.String.class, java.lang.String.class}
+        )
+    })
     public void testPreferenceChangeEventException() {
         try {
             event = new PreferenceChangeEvent(null, "key", "value");
@@ -40,6 +55,15 @@ public class PreferenceChangeEventTest extends TestCase {
         }
     }
 
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "PreferenceChangeEvent",
+          methodArgs = {java.util.prefs.Preferences.class, java.lang.String.class, java.lang.String.class}
+        )
+    })
     public void testConstructorNullValue() {
         event = new PreferenceChangeEvent(Preferences.userRoot(), "key", null);
         assertEquals("key", event.getKey());
@@ -66,6 +90,15 @@ public class PreferenceChangeEventTest extends TestCase {
         assertSame(Preferences.userRoot(), event.getSource());
     }
 
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "PreferenceChangeEvent",
+          methodArgs = {java.util.prefs.Preferences.class, java.lang.String.class, java.lang.String.class}
+        )
+    })
     public void testConstructor() {
         event = new PreferenceChangeEvent(Preferences.userRoot(), "key",
                 "value");
@@ -75,6 +108,15 @@ public class PreferenceChangeEventTest extends TestCase {
         assertSame(Preferences.userRoot(), event.getSource());
     }
 
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Verifies serialization",
+      targets = {
+        @TestTarget(
+          methodName = "!Serialization",
+          methodArgs = {}
+        )
+    })
     public void testSerialization() throws Exception {
         event = new PreferenceChangeEvent(Preferences.userRoot(), "key",
                 "value");
@@ -85,67 +127,94 @@ public class PreferenceChangeEventTest extends TestCase {
         }
     }
     
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test is correct, functionality checked in separate Mock class.",
+      targets = {
+        @TestTarget(
+          methodName = "getKey",
+          methodArgs = {}
+        )
+    })
     public void testGetKey() {
-		AbstractPreferences parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-
-		AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
-
-		MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
-				MockPreferenceChangeListener.TEST_GET_KEY);
-		pref.addPreferenceChangeListener(pl);
-		try {
-			pref.putInt("key_int", Integer.MAX_VALUE);
-			assertEquals(1, pl.getChanged());
-			assertTrue(pl.getResult());
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-		}
+        AbstractPreferences parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+
+        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
+
+        MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
+                MockPreferenceChangeListener.TEST_GET_KEY);
+        pref.addPreferenceChangeListener(pl);
+        try {
+            pref.putInt("key_int", Integer.MAX_VALUE);
+            assertEquals(1, pl.getChanged());
+            assertTrue(pl.getResult());
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+        }
     }
     
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test is correct, functionality checked in separate Mock class.",
+      targets = {
+        @TestTarget(
+          methodName = "getNewValue",
+          methodArgs = {}
+        )
+    })
     public void testGetNewValue() {
-		AbstractPreferences parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-
-		AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
-
-		MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
-				MockPreferenceChangeListener.TEST_GET_NEW_VALUE);
-		pref.addPreferenceChangeListener(pl);
-		try {
-			pref.putInt("key_int", Integer.MAX_VALUE);
-			assertEquals(1, pl.getChanged());
-			assertTrue(pl.getResult());
-			pl.reset();
-			
-			pref.putInt("key_int", Integer.MAX_VALUE);
-			assertEquals(1, pl.getChanged());
-			assertTrue(pl.getResult());
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-		}
+        AbstractPreferences parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+
+        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
+
+        MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
+                MockPreferenceChangeListener.TEST_GET_NEW_VALUE);
+        pref.addPreferenceChangeListener(pl);
+        try {
+            pref.putInt("key_int", Integer.MAX_VALUE);
+            assertEquals(1, pl.getChanged());
+            assertTrue(pl.getResult());
+            pl.reset();
+            
+            pref.putInt("key_int", Integer.MAX_VALUE);
+            assertEquals(1, pl.getChanged());
+            assertTrue(pl.getResult());
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+        }
     }
     
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test is correct, functionality checked in separate Mock class.",
+      targets = {
+        @TestTarget(
+          methodName = "getNode",
+          methodArgs = {}
+        )
+    })
     public void testGetNode() {
-		AbstractPreferences parent = (AbstractPreferences) Preferences
-				.userNodeForPackage(Preferences.class);
-
-		AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
-
-		MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
-				MockPreferenceChangeListener.TEST_GET_NODE);
-		pref.addPreferenceChangeListener(pl);
-		try {
-			pref.putInt("key_int", Integer.MAX_VALUE);
-			assertEquals(1, pl.getChanged());
-			assertTrue(pl.getResult());
-			pl.reset();
-
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-		}
+        AbstractPreferences parent = (AbstractPreferences) Preferences
+                .userNodeForPackage(Preferences.class);
+
+        AbstractPreferences pref = (AbstractPreferences) parent.node("mock");
+
+        MockPreferenceChangeListener pl = new MockPreferenceChangeListener(
+                MockPreferenceChangeListener.TEST_GET_NODE);
+        pref.addPreferenceChangeListener(pl);
+        try {
+            pref.putInt("key_int", Integer.MAX_VALUE);
+            assertEquals(1, pl.getChanged());
+            assertTrue(pl.getResult());
+            pl.reset();
+
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+        }
     }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeListenerTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeListenerTest.java
index c417052..3dd2b17 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeListenerTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferenceChangeListenerTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.util.prefs.PreferenceChangeEvent;
 import java.util.prefs.PreferenceChangeListener;
 import java.util.prefs.Preferences;
@@ -25,28 +30,38 @@ import junit.framework.TestCase;
 /**
  * 
  */
+@TestTargetClass(PreferenceChangeListener.class)
 public class PreferenceChangeListenerTest extends TestCase {
 
-	PreferenceChangeListener l;
+    PreferenceChangeListener l;
 
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		l = new PreferenceChangeListenerImpl();
-	}
+    /*
+     * @see TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        l = new PreferenceChangeListenerImpl();
+    }
 
-	public void testPreferenceChange() {
-		l.preferenceChange(new PreferenceChangeEvent(Preferences.userRoot(),
-				"", ""));
-	}
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Testing Interface",
+      targets = {
+        @TestTarget(
+          methodName = "preferenceChange",
+          methodArgs = {java.util.prefs.PreferenceChangeEvent.class}
+        )
+    })
+    public void testPreferenceChange() {
+        l.preferenceChange(new PreferenceChangeEvent(Preferences.userRoot(),
+                "", ""));
+    }
 
-	public static class PreferenceChangeListenerImpl implements
-			PreferenceChangeListener {
-		public void preferenceChange(PreferenceChangeEvent pce) {
-		}
+    public static class PreferenceChangeListenerImpl implements
+            PreferenceChangeListener {
+        public void preferenceChange(PreferenceChangeEvent pce) {
+        }
 
-	}
+    }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesFactoryTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesFactoryTest.java
index d0c3541..2badc99 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesFactoryTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesFactoryTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.util.prefs.Preferences;
 import java.util.prefs.PreferencesFactory;
 
@@ -24,36 +29,55 @@ import junit.framework.TestCase;
 /**
  * 
  */
+@TestTargetClass(PreferencesFactory.class)
 public class PreferencesFactoryTest extends TestCase {
 
-	PreferencesFactory f;
+    PreferencesFactory f;
 
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		f = new PreferencesFactoryImpl();
-	}
+    /*
+     * @see TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        f = new PreferencesFactoryImpl();
+    }
 
-	public void testUserRoot() {
-		f.userRoot();
-	}
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Testing Interface",
+      targets = {
+        @TestTarget(
+          methodName = "userRoot",
+          methodArgs = {}
+        )
+    })
+    public void testUserRoot() {
+        f.userRoot();
+    }
 
-	public void testSystemRoot() {
-		f.systemRoot();
-	}
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Testing Interface",
+      targets = {
+        @TestTarget(
+          methodName = "userRoot",
+          methodArgs = {}
+        )
+    })
+    public void testSystemRoot() {
+        f.systemRoot();
+    }
 
-	public static class PreferencesFactoryImpl implements PreferencesFactory {
+    public static class PreferencesFactoryImpl implements PreferencesFactory {
 
-		public Preferences userRoot() {
-			return null;
-		}
+        public Preferences userRoot() {
+            return null;
+        }
 
-		public Preferences systemRoot() {
-			return null;
-		}
+        public Preferences systemRoot() {
+            return null;
+        }
 
-	}
+    }
 
 }
diff --git a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesTest.java b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesTest.java
index 23248c0..25f891e 100644
--- a/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesTest.java
+++ b/prefs/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/PreferencesTest.java
@@ -16,6 +16,11 @@
 
 package org.apache.harmony.prefs.tests.java.util.prefs;
 
+import dalvik.annotation.TestTargetClass;
+import dalvik.annotation.TestInfo;
+import dalvik.annotation.TestLevel;
+import dalvik.annotation.TestTarget;
+
 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.io.InputStream;
@@ -35,1419 +40,1892 @@ import junit.framework.TestCase;
 /**
  * 
  */
+@TestTargetClass(Preferences.class)
 public class PreferencesTest extends TestCase {
 
-	MockSecurityManager manager = new MockSecurityManager();
-
-	MockInputStream stream = null;
-	
-	final static String longKey;
-	
-	final static String longValue;
-
-	InputStream in;
-	static {
-		StringBuffer key = new StringBuffer(Preferences.MAX_KEY_LENGTH);
-		for (int i = 0; i < Preferences.MAX_KEY_LENGTH; i++) {
-			key.append('a');
-		}
-		longKey = key.toString();
-		
-		StringBuffer value = new StringBuffer(Preferences.MAX_VALUE_LENGTH);
-		for (int i = 0; i < Preferences.MAX_VALUE_LENGTH; i++) {
-			value.append('a');
-		}
-		longValue = value.toString();
-	}
-
-	/*
-	 * @see TestCase#setUp()
-	 */
-	protected void setUp() throws Exception {
-		super.setUp();
-		in = new ByteArrayInputStream(
-				"<!DOCTYPE preferences SYSTEM \"http://java.sun.com/dtd/preferences.dtd\"><preferences><root type=\"user\"><map></map></root></preferences>"
-						.getBytes("UTF-8"));
-		stream = new MockInputStream(in);
-	}
-
-	/*
-	 * @see TestCase#tearDown()
-	 */
-	protected void tearDown() throws Exception {
-		super.tearDown();
-		stream.close();
-	}
-
-	public void testSystemNodeForPackage() throws BackingStoreException {
-		Preferences p = null;
-		try {
-			p = Preferences.systemNodeForPackage(Object.class);
-		} catch (SecurityException e) {
-			// may be caused by absence of privileges on the underlying OS
-			return;
-		}
-		assertEquals("/java/lang", p.absolutePath());
-		assertTrue(p instanceof AbstractPreferences);
-		Preferences root = Preferences.systemRoot();
-		Preferences parent = root.node("java");
-		assertSame(parent, p.parent());
-		assertFalse(p.isUserNode());
-		assertEquals("lang", p.name());
-		assertEquals("System Preference Node: " + p.absolutePath(), p
-				.toString());
-		try {
-			assertEquals(0, p.childrenNames().length);
-		} catch (BackingStoreException e) {
-			// could be thrown according to specification
-		}
-		try {
-			assertEquals(0, p.keys().length);
-		} catch (BackingStoreException e) {
-			// could be thrown according to specification
-		}
-
-		try {
-			p = Preferences.userNodeForPackage(null);
-			fail("NullPointerException has not been thrown");
-		} catch (NullPointerException e) {
-			// expected
-		}
-	}
-
-	public void testSystemRoot() throws BackingStoreException {
-		Preferences p = Preferences.systemRoot();
-		assertTrue(p instanceof AbstractPreferences);
-		assertEquals("/", p.absolutePath());
-		assertSame(null, p.parent());
-		assertFalse(p.isUserNode());
-		assertEquals("", p.name());
-		assertEquals("System Preference Node: " + p.absolutePath(), p
-				.toString());
-		// assertEquals(0, p.childrenNames().length);
-		// assertEquals(0, p.keys().length);
-	}
-
-	public void testConsts() {
-		assertEquals(80, Preferences.MAX_KEY_LENGTH);
-		assertEquals(80, Preferences.MAX_NAME_LENGTH);
-		assertEquals(8192, Preferences.MAX_VALUE_LENGTH);
-	}
-
-	public void testUserNodeForPackage() throws BackingStoreException {
-		Preferences p = Preferences.userNodeForPackage(Object.class);
-		assertEquals("/java/lang", p.absolutePath());
-		assertTrue(p instanceof AbstractPreferences);
-		Preferences root = Preferences.userRoot();
-		Preferences parent = root.node("java");
-		assertSame(parent, p.parent());
-		assertTrue(p.isUserNode());
-		assertEquals("lang", p.name());
-		assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
-		assertEquals(0, p.childrenNames().length);
-		assertEquals(0, p.keys().length);
-
-		try {
-			p = Preferences.userNodeForPackage(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-	}
-
-	public void testUserRoot() throws BackingStoreException {
-		Preferences p = Preferences.userRoot();
-		assertTrue(p instanceof AbstractPreferences);
-		assertEquals("/", p.absolutePath());
-		assertSame(null, p.parent());
-		assertTrue(p.isUserNode());
-		assertEquals("", p.name());
-		assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
-		// assertEquals(0, p.childrenNames().length);
-		// assertEquals(p.keys().length, 0);
-	}
-
-	public void testImportPreferences() throws Exception {
-		Preferences prefs = null;
-		try {
-			prefs = Preferences.userNodeForPackage(PreferencesTest.class);
-			// assertEquals(0, prefs.childrenNames().length);
-			// assertFalse(prefs.nodeExists("mock/child/grandson"));
-
-			prefs.put("prefskey", "oldvalue");
-			prefs.put("prefskey2", "oldvalue2");
-			in = getClass().getResourceAsStream("/prefs/java/util/prefs/userprefs.xml");
-			Preferences.importPreferences(in);
-
-			prefs = Preferences.userNodeForPackage(PreferencesTest.class);
-			assertEquals(1, prefs.childrenNames().length);
-			assertTrue(prefs.nodeExists("mock/child/grandson"));
-			assertEquals("newvalue", prefs.get("prefskey", null));
-			assertEquals("oldvalue2", prefs.get("prefskey2", null));
-			assertEquals("newvalue3", prefs.get("prefskey3", null));
-
-			in = PreferencesTest.class
-					.getResourceAsStream("/prefs/java/util/prefs/userprefs-badform.xml");
-			try {
-				Preferences.importPreferences(in);
-				fail();
-			} catch (InvalidPreferencesFormatException e) {
-			}
-
-			in = PreferencesTest.class
-					.getResourceAsStream("/prefs/java/util/prefs/userprefs-badtype.xml");
-			try {
-				Preferences.importPreferences(in);
-				fail();
-			} catch (InvalidPreferencesFormatException e) {
-			}
-
-	//		in = PreferencesTest.class
-	//				.getResourceAsStream("/prefs/java/util/prefs/userprefs-badencoding.xml");
-	//		try {
-	//			Preferences.importPreferences(in);
-	//			fail();
-	//		} catch (InvalidPreferencesFormatException e) {
-	//		}
-
-			in = PreferencesTest.class
-					.getResourceAsStream("/prefs/java/util/prefs/userprefs-higherversion.xml");
-			try {
-				Preferences.importPreferences(in);
-				fail();
-			} catch (InvalidPreferencesFormatException e) {
-			}
-
-			in = PreferencesTest.class
-					.getResourceAsStream("/prefs/java/util/prefs/userprefs-ascii.xml");
-			Preferences.importPreferences(in);
-			prefs = Preferences.userNodeForPackage(PreferencesTest.class);
-		} finally {
-			try {
-				prefs = Preferences.userRoot().node("tests");
-				prefs.removeNode();
-			} catch (Exception e) {
-			}
-		}
-	}
-
-	public void testImportPreferencesException() throws Exception {
-		try {
-			Preferences.importPreferences(null);
-			fail();
-		} catch (MalformedURLException e) {
-		}
-
-		byte[] source = new byte[0];
-		InputStream in = new ByteArrayInputStream(source);
-		try {
-			Preferences.importPreferences(in);
-			fail();
-		} catch (InvalidPreferencesFormatException e) {
-		}
-
-		stream.setResult(MockInputStream.exception);
-		try {
-			Preferences.importPreferences(stream);
-			fail();
-		} catch (IOException e) {
-		}
-
-		stream.setResult(MockInputStream.runtimeException);
-		try {
-			Preferences.importPreferences(stream);
-			fail();
-		} catch (RuntimeException e) {
-		}
-	}
-
-	public void testSecurity() throws InvalidPreferencesFormatException,
-			IOException {
-		try {
-			manager.install();
-			try {
-				Preferences.userRoot();
-				fail();
-			} catch (SecurityException e) {
-			}
-			try {
-				Preferences.systemRoot();
-				fail();
-			} catch (SecurityException e) {
-			}
-			try {
-				Preferences.userNodeForPackage(null);
-				fail();
-			} catch (SecurityException e) {
-			}
-
-			try {
-				Preferences.systemNodeForPackage(null);
-				fail();
-			} catch (SecurityException e) {
-			}
-
-			try {
-				Preferences.importPreferences(stream);
-				fail();
-			} catch (SecurityException e) {
-			}
-		} finally {
-			manager.restoreDefault();
-		}
-	}
-
-	public void testAbstractMethods() {
-		Preferences p = new MockPreferences();
-		p.absolutePath();
-		try {
-			p.childrenNames();
-		} catch (BackingStoreException e4) {
-		}
-		try {
-			p.clear();
-		} catch (BackingStoreException e5) {
-		}
-		try {
-			p.exportNode(null);
-		} catch (IOException e6) {
-		} catch (BackingStoreException e6) {
-		}
-		try {
-			p.exportSubtree(null);
-		} catch (IOException e7) {
-		} catch (BackingStoreException e7) {
-		}
-		try {
-			p.flush();
-		} catch (BackingStoreException e8) {
-		}
-		p.get(null, null);
-		p.getBoolean(null, false);
-		p.getByteArray(null, null);
-		p.getFloat(null, 0.1f);
-		p.getDouble(null, 0.1);
-		p.getInt(null, 1);
-		p.getLong(null, 1l);
-		p.isUserNode();
-		try {
-			p.keys();
-		} catch (BackingStoreException e) {
-		}
-		p.name();
-		p.node(null);
-		try {
-			p.nodeExists(null);
-		} catch (BackingStoreException e1) {
-		}
-		p.parent();
-		p.put(null, null);
-		p.putBoolean(null, false);
-		p.putByteArray(null, null);
-		p.putDouble(null, 1);
-		p.putFloat(null, 1f);
-		p.putInt(null, 1);
-		p.putLong(null, 1l);
-		p.remove(null);
-		try {
-			p.removeNode();
-		} catch (BackingStoreException e2) {
-		}
-		p.addNodeChangeListener(null);
-		p.addPreferenceChangeListener(null);
-		p.removeNodeChangeListener(null);
-		p.removePreferenceChangeListener(null);
-		try {
-			p.sync();
-		} catch (BackingStoreException e3) {
-		}
-		p.toString();
-	}
-
-	public void testConstructor() {
-		MockPreferences mp = new MockPreferences();
-		assertEquals(mp.getClass(), MockPreferences.class);
-	}
-
-	public void testToString() {
-		Preferences p1 = Preferences.userNodeForPackage(Preferences.class);
-		assertNotNull(p1.toString());
-
-		Preferences p2 = Preferences.systemRoot();
-		assertNotNull(p2.toString());
-
-		Preferences p3 = Preferences.userRoot();
-		assertNotNull(p3.toString());
-	}
-	/**
-	 * @test java.util.prefs.Preferences#absolutePath()
-	 *
-	 */
-	public void testAbsolutePath() {
-		Preferences p = Preferences.userNodeForPackage(Preferences.class);
-		assertEquals("/java/util/prefs", p.absolutePath());
-
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#childrenNames()
-	 *
-	 */
-	public void testChildrenNames() throws BackingStoreException {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-
-		Preferences child1 = pref.node("child1");
-
-		pref.node("child2");
-		pref.node("child3");
-		child1.node("subchild1");
-
-		assertSame(pref, child1.parent());
-		assertEquals(4, pref.childrenNames().length);
-		assertEquals("child1", pref.childrenNames()[0]);
-		assertEquals(1, child1.childrenNames().length);
-		assertEquals("subchild1", child1.childrenNames()[0]);
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#clear()
-	 *
-	 */
-	public void testClear() throws BackingStoreException {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		pref.put("testClearKey", "testClearValue");
-		pref.put("testClearKey1", "testClearValue1");
-		assertEquals("testClearValue", pref.get("testClearKey", null));
-		assertEquals("testClearValue1", pref.get("testClearKey1", null));
-		pref.clear();
-		assertNull(pref.get("testClearKey", null));
-		assertNull(pref.get("testClearKey1", null));
-	}	
-
-	/**
-	 * @test java.util.prefs.Preferences#get(String key, String def)
-	 *
-	 */
-	public void testGet() throws BackingStoreException {
-		Preferences root = Preferences.userNodeForPackage(Preferences.class);
-		Preferences pref = root.node("mock");
-		assertNull(pref.get("", null));
-		assertEquals("default", pref.get("key", "default"));
-		assertNull(pref.get("key", null));
-		pref.put("testGetkey", "value");
-		assertNull(pref.get("testGetKey", null));
-		assertEquals("value", pref.get("testGetkey", null));
-
-		try {
-			pref.get(null, "abc");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.get("", "abc");
-		pref.get("key", null);
-		pref.get("key", "");
-		pref.putFloat("floatKey", 1.0f);
-		assertEquals("1.0", pref.get("floatKey", null));
-
-		pref.removeNode();
-		try {
-			pref.get("key", "abc");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-		try {
-			pref.get(null, "abc");
-			fail();
-		} catch (NullPointerException e) {
-		}
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#getBoolean(String key, boolean def)
-	 *
-	 */
-	public void testGetBoolean() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getBoolean(null, false);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetBooleanKey", "false");
-		pref.put("testGetBooleanKey2", "value");
-		assertFalse(pref.getBoolean("testGetBooleanKey", true));
-		assertTrue(pref.getBoolean("testGetBooleanKey2", true));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#getByteArray(String key, byte[] def)
-	 *
-	 */
-	public void testGetByteArray() throws UnsupportedEncodingException {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		byte[] b64Array = new byte[] { 0x59, 0x57, 0x4a, 0x6a };// BASE64
-
-		pref.put("testGetByteArrayKey", "abc=");
-		pref.put("testGetByteArrayKey2", new String(b64Array));
-		pref.put("invalidKey", "<>?");
-		assertTrue(Arrays.equals(new byte[] { 105, -73 }, pref.getByteArray(
-				"testGetByteArrayKey", new byte[0])));
-		assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
-				.getByteArray("testGetByteArrayKey2", new byte[0])));
-		assertTrue(Arrays.equals(new byte[0], pref.getByteArray("invalidKey",
-				new byte[0])));
-
-		pref.putByteArray("testGetByteArrayKey3", b64Array);
-		pref.putByteArray("testGetByteArrayKey4", "abc".getBytes());
-		assertTrue(Arrays.equals(b64Array, pref.getByteArray(
-				"testGetByteArrayKey3", new byte[0])));
-		assertTrue(Arrays.equals("abc".getBytes(), pref.getByteArray(
-				"testGetByteArrayKey4", new byte[0])));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#getDouble(String key, double def)
-	 *
-	 */
-	public void testGetDouble() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getDouble(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetDoubleKey", "1");
-		pref.put("testGetDoubleKey2", "value");
-		pref.putDouble("testGetDoubleKey3", 1);
-		pref.putInt("testGetDoubleKey4", 1);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey", 0.0), 0);
-		assertEquals(0.0, pref.getDouble("testGetDoubleKey2", 0.0), 0);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey3", 0.0), 0);
-		assertEquals(1.0, pref.getDouble("testGetDoubleKey4", 0.0), 0);
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#getFloat(String key, float def)
-	 *
-	 */
-	public void testGetFloat() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getFloat(null, 0f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.put("testGetFloatKey", "1");
-		pref.put("testGetFloatKey2", "value");
-		assertEquals(1f, pref.getFloat("testGetFloatKey", 0f), 0); //$NON-NLS-1$
-		assertEquals(0f, pref.getFloat("testGetFloatKey2", 0f), 0);
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#getInt(String key, int def)
-	 *
-	 */
-	public void testGetInt() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getInt(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetIntKey", "1");
-		pref.put("testGetIntKey2", "value");
-		assertEquals(1, pref.getInt("testGetIntKey", 0));
-		assertEquals(0, pref.getInt("testGetIntKey2", 0));
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#getLong(String key, long def)
-	 *
-	 */
-	public void testGetLong() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.getLong(null, 0);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.put("testGetLongKey", "1");
-		pref.put("testGetLongKey2", "value");
-		assertEquals(1, pref.getInt("testGetLongKey", 0));
-		assertEquals(0, pref.getInt("testGetLongKey2", 0));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#isUserNode()
-	 *
-	 */
-	public void testIsUserNode() {
-		Preferences pref1 = Preferences.userNodeForPackage(Preferences.class);
-		assertTrue(pref1.isUserNode());
-
-		Preferences pref2 = Preferences.systemNodeForPackage(Preferences.class);
-		assertFalse(pref2.isUserNode());
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#keys()
-	 *
-	 */
-	public void testKeys() throws BackingStoreException {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		pref.clear();
-		
-		pref.put("key0", "value");
-		pref.put("key1", "value1");
-		pref.put("key2", "value2");
-		pref.put("key3", "value3");
-
-		String[] keys = pref.keys();
-		assertEquals(4, keys.length);
-		for (int i = 0; i < keys.length; i++) {
-			assertEquals(0, keys[i].indexOf("key"));
-			assertEquals(4, keys[i].length());
-		}
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#name()
-	 *
-	 */
-	public void testName() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		Preferences child = pref.node("mock");
-		assertEquals("mock", child.name());
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#node(String pathName)
-	 *
-	 */
-	public void testNode() throws BackingStoreException {
-		StringBuffer name = new StringBuffer(Preferences.MAX_NAME_LENGTH);
-		for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) {
-			name.append('a');
-		}
-		String longName = name.toString();
-		
-		Preferences root = Preferences.userRoot();
-		Preferences parent = Preferences
-				.userNodeForPackage(Preferences.class);
-		Preferences pref = parent.node("mock");
-		
-		try {
-			pref.node(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.node("/java/util/prefs/");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.node("/java//util/prefs");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.node(longName + "a");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		assertNotNull(pref.node(longName));
-
-		assertSame(root, pref.node("/"));
-
-		Preferences prefs = pref.node("/java/util/prefs");
-		assertSame(prefs, parent);
-
-		assertSame(pref, pref.node(""));
-
-		if (!(pref instanceof MockAbstractPreferences)) {
-			return;
-		}
-		MockAbstractPreferences child = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
-				.publicChildSpi("child");
-		assertSame(child, pref.node("child"));
-
-		Preferences child2 = pref.node("child2");
-		assertSame(child2, ((MockAbstractPreferences) pref)
-				.publicChildSpi("child2"));
-
-		Preferences grandchild = pref.node("child/grandchild");
-		assertSame(grandchild, child.childSpi("grandchild"));
-		assertSame(grandchild, child.cachedChildrenImpl()[0]);
-		grandchild.removeNode();
-		assertNotSame(grandchild, pref.node("child/grandchild"));
-
-		grandchild = pref.node("child3/grandchild");
-		AbstractPreferences[] childs = ((MockAbstractPreferences) pref)
-				.cachedChildrenImpl();
-		Preferences child3 = child;
-		for (int i = 0; i < childs.length; i++) {
-			if (childs[i].name().equals("child3")) {
-				child3 = childs[i];
-				break;
-			}
-		}
-		assertSame(child3, grandchild.parent());
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#nodeExists(String pathName)
-	 *
-	 */
-	public void testNodeExists() throws BackingStoreException {
-
-		Preferences parent = Preferences
-				.userNodeForPackage(Preferences.class);
-		Preferences pref = parent.node("mock");
-		
-		try {
-			pref.nodeExists(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.nodeExists("/java/util/prefs/");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.nodeExists("/java//util/prefs");
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		assertTrue(pref.nodeExists("/"));
-
-		assertTrue(pref.nodeExists("/java/util/prefs"));
-
-		assertTrue(pref.nodeExists(""));
-
-		assertFalse(pref.nodeExists("child"));
-		Preferences grandchild = pref.node("child/grandchild");
-		assertTrue(pref.nodeExists("child"));
-		assertTrue(pref.nodeExists("child/grandchild"));
-		grandchild.removeNode();
-		assertTrue(pref.nodeExists("child"));
-		assertFalse(pref.nodeExists("child/grandchild"));
-		assertFalse(grandchild.nodeExists(""));
-
-		assertFalse(pref.nodeExists("child2/grandchild"));
-		pref.node("child2/grandchild");
-		assertTrue(pref.nodeExists("child2/grandchild"));
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#parent()
-	 *
-	 */
-	public void testParent() {
-		Preferences parent = Preferences
-				.userNodeForPackage(Preferences.class);
-		Preferences pref = parent.node("mock");
-		
-		assertSame(parent, pref.parent());
-		
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#put(String key, String value)
-	 *
-	 */
-	public void testPut() throws BackingStoreException {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		pref.put("", "emptyvalue");
-		assertEquals("emptyvalue", pref.get("", null));
-		pref.put("testPutkey", "value1");
-		assertEquals("value1", pref.get("testPutkey", null));
-		pref.put("testPutkey", "value2");
-		assertEquals("value2", pref.get("testPutkey", null));
-
-		pref.put("", "emptyvalue");
-		assertEquals("emptyvalue", pref.get("", null));
-
-		try {
-			pref.put(null, "value");
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.put("key", null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.put(longKey, longValue);
-		try {
-			pref.put(longKey + 1, longValue);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.put(longKey, longValue + 1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		pref.removeNode();
-		try {
-			pref.put(longKey, longValue + 1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		try {
-			pref.put(longKey, longValue);
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#putBoolean(String key, boolean value)
-	 *
-	 */
-	public void testPutBoolean() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putBoolean(null, false);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putBoolean(longKey, false);
-		try {
-			pref.putBoolean(longKey + "a", false);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putBoolean("testPutBooleanKey", false);
-		assertEquals("false", pref.get("testPutBooleanKey", null));
-		assertFalse(pref.getBoolean("testPutBooleanKey", true));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#putDouble(String key, double value)
-	 *
-	 */
-	public void testPutDouble() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putDouble(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putDouble(longKey, 3);
-		try {
-			pref.putDouble(longKey + "a", 3);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putDouble("testPutDoubleKey", 3);
-		assertEquals("3.0", pref.get("testPutDoubleKey", null));
-		assertEquals(3, pref.getDouble("testPutDoubleKey", 0), 0);
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#putFloat(String key, float value)
-	 *
-	 */
-	public void testPutFloat() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putFloat(null, 3f);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putFloat(longKey, 3f);
-		try {
-			pref.putFloat(longKey + "a", 3f);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putFloat("testPutFloatKey", 3f);
-		assertEquals("3.0", pref.get("testPutFloatKey", null));
-		assertEquals(3f, pref.getFloat("testPutFloatKey", 0), 0);
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#putInt(String key, int value)
-	 *
-	 */
-	public void testPutInt() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putInt(null, 3);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putInt(longKey, 3);
-		try {
-			pref.putInt(longKey + "a", 3);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putInt("testPutIntKey", 3);
-		assertEquals("3", pref.get("testPutIntKey", null));
-		assertEquals(3, pref.getInt("testPutIntKey", 0));
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#putLong(String key, long value)
-	 *
-	 */
-	public void testPutLong() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putLong(null, 3L);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		pref.putLong(longKey, 3L);
-		try {
-			pref.putLong(longKey + "a", 3L);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.putLong("testPutLongKey", 3L);
-		assertEquals("3", pref.get("testPutLongKey", null));
-		assertEquals(3L, pref.getLong("testPutLongKey", 0));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#putByteArray(String key, byte[] value)
-	 *
-	 */
-	public void testPutByteArray() {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		try {
-			pref.putByteArray(null, new byte[0]);
-			fail();
-		} catch (NullPointerException e) {
-		}
-		try {
-			pref.putByteArray("testPutByteArrayKey4", null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		pref.putByteArray(longKey, new byte[0]);
-		try {
-			pref.putByteArray(longKey + "a", new byte[0]);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		byte[] longArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.74)];
-		byte[] longerArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.75) + 1];
-		pref.putByteArray(longKey, longArray);
-		try {
-			pref.putByteArray(longKey, longerArray);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-		pref.putByteArray("testPutByteArrayKey", new byte[0]);
-		assertEquals("", pref.get("testPutByteArrayKey", null));
-		assertTrue(Arrays.equals(new byte[0], pref.getByteArray(
-				"testPutByteArrayKey", null)));
-
-		pref.putByteArray("testPutByteArrayKey3", new byte[] { 'a', 'b', 'c' });
-		assertEquals("YWJj", pref.get("testPutByteArrayKey3", null));
-		assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
-				.getByteArray("testPutByteArrayKey3", null)));
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#remove(String key)
-	 *
-	 */
-	public void testRemove() throws BackingStoreException {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		pref.remove("key");
-
-		pref.put("key", "value");
-		assertEquals("value", pref.get("key", null));
-		pref.remove("key");
-		assertNull(pref.get("key", null));
-
-		pref.remove("key");
-
-		try {
-			pref.remove(null);
-		} catch (NullPointerException e) {
-		}
-
-		pref.removeNode();
-		try {
-			pref.remove("key");
-			fail();
-		} catch (IllegalStateException e) {
-		}
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#removeNode()
-	 *
-	 */
-	public void testRemoveNode() throws BackingStoreException {
-		Preferences pref = Preferences
-		.userNodeForPackage(Preferences.class);
-		Preferences child = pref.node("child");
-		Preferences child1 = pref.node("child1");
-		Preferences grandchild = child.node("grandchild");
-
-		pref.removeNode();
-
-		assertFalse(child.nodeExists(""));
-		assertFalse(child1.nodeExists(""));
-		assertFalse(grandchild.nodeExists(""));
-		assertFalse(pref.nodeExists(""));
-	}
-	
-	
-	/**
-	 * @test java.util.prefs.Preferences#addNodeChangeListener(NodeChangeListener ncl)
-	 *
-	 */
-	public void testAddNodeChangeListener() throws BackingStoreException {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.addNodeChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		Preferences child1 = null;
-		Preferences child2 = null;
-		Preferences child3 = null;
-		
-		MockNodeChangeListener nl = null;
-		// To get existed node doesn't create the change event
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock1");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-			child2 = pref.node("mock1");
-			assertEquals(0, nl.getAdded());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			child1.removeNode();
-		}
-		// same listener can be added twice, and must be removed twice
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock2");
-			assertEquals(2, nl.getAdded());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			pref.removeNodeChangeListener(nl);
-			child1.removeNode();
-		}
-		// test remove event
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock3");
-			child1.removeNode();
-			assertEquals(1, nl.getRemoved());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-		}
-		// test remove event with two listeners
-		try {
-			nl = new MockNodeChangeListener();
-			pref.addNodeChangeListener(nl);
-			pref.addNodeChangeListener(nl);
-			child1 = pref.node("mock6");
-			child1.removeNode();
-			assertEquals(2, nl.getRemoved());
-			nl.reset();
-		} finally {
-			pref.removeNodeChangeListener(nl);
-			pref.removeNodeChangeListener(nl);
-		}
-		// test add/remove indirect children, or remove several children at the
-		// same time
-		try {
-			nl = new MockNodeChangeListener();
-			child1 = pref.node("mock4");
-			child1.addNodeChangeListener(nl);
-			child2 = pref.node("mock4/mock5");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-			child3 = pref.node("mock4/mock5/mock6");
-			assertEquals(0, nl.getAdded());
-			nl.reset();
-
-			child3.removeNode();
-			assertEquals(0, nl.getRemoved());
-			nl.reset();
-
-			child3 = pref.node("mock4/mock7");
-			assertEquals(1, nl.getAdded());
-			nl.reset();
-
-			child1.removeNode();
-			assertEquals(2, nl.getRemoved());
-			nl.reset();
-		} finally {
-			try {
-				child1.removeNode();
-			} catch (Exception e) {
-			}
-		}
-
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#addPreferenceChangeListener(PreferenceChangeListener pcl)
-	 *
-	 */
-	public void testAddPreferenceChangeListener() {
-		
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		MockPreferenceChangeListener pl = null;
-		
-		// TODO: start from here
-		try {
-			pref.addPreferenceChangeListener(null);
-			fail();
-		} catch (NullPointerException e) {
-		}
-
-		// To get existed node doesn't create the change event
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.putInt("mock1", 123);
-			assertEquals(1, pl.getChanged());
-			pref.putLong("long_key", Long.MAX_VALUE);
-			assertEquals(2, pl.getChanged());
-			pl.reset();
-			try {
-				pref.clear();
-				assertEquals(2, pl.getChanged());
-			} catch(BackingStoreException bse) {
-				pl.reset();
-				fail("BackingStoreException is thrown");
-			}
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-			//child1.removeNode();
-		}
-				      
-		// same listener can be added twice, and must be removed twice
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.addPreferenceChangeListener(pl);
-			pref.putFloat("float_key", Float.MIN_VALUE);
-			assertEquals(2, pl.getChanged());
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-			pref.removePreferenceChangeListener(pl);
-
-		}
-		// test remove event
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.putDouble("double_key", Double.MAX_VALUE);
-			assertEquals(1, pl.getChanged());
-			try {
-				pref.clear();
-				assertEquals(3, pl.getChanged());
-			} catch(BackingStoreException bse) {
-				fail("BackingStoreException is thrown");
-			}
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-		}
-		// test remove event with two listeners
-		try {
-			pl = new MockPreferenceChangeListener();
-			pref.addPreferenceChangeListener(pl);
-			pref.addPreferenceChangeListener(pl);
-			pref.putByteArray("byte_array_key", new byte [] {1 ,2 , 3});
-			try {
-				pref.clear();
-				assertEquals(4, pl.getChanged());
-			} catch(BackingStoreException bse) {
-				fail("BackingStoreException is thrown");
-			}
-			pl.reset();
-		} finally {
-			pref.removePreferenceChangeListener(pl);
-			pref.removePreferenceChangeListener(pl);
-		}
-
-	}
-	
-	/**
-	 * @test java.util.prefs.Preferences#removeNodeChangeListener(NodeChangeListener ncl)
-	 *
-	 */
-	public void testRemoveNodeChangeListener() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.removeNodeChangeListener(null);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		MockNodeChangeListener l1 = new MockNodeChangeListener();
-		MockNodeChangeListener l2 = new MockNodeChangeListener();
-		pref.addNodeChangeListener(l1);
-		pref.addNodeChangeListener(l1);
-
-		pref.removeNodeChangeListener(l1);
-		pref.removeNodeChangeListener(l1);
-		try {
-			pref.removeNodeChangeListener(l1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		try {
-			pref.removeNodeChangeListener(l2);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-	}
-
-	/**
-	 * @test java.util.prefs.Preferences#removePreferenceChangeListener(PreferenceChangeListener pcl)
-	 *
-	 */
-	public void testRemovePreferenceChangeListener() {
-		Preferences pref = Preferences.userNodeForPackage(Preferences.class);
-		try {
-			pref.removePreferenceChangeListener(null);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		MockPreferenceChangeListener l1 = new MockPreferenceChangeListener();
-		MockPreferenceChangeListener l2 = new MockPreferenceChangeListener();
-		pref.addPreferenceChangeListener(l1);
-		pref.addPreferenceChangeListener(l1);
-		try {
-			pref.removePreferenceChangeListener(l2);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-		pref.removePreferenceChangeListener(l1);
-		pref.removePreferenceChangeListener(l1);
-		try {
-			pref.removePreferenceChangeListener(l1);
-			fail();
-		} catch (IllegalArgumentException e) {
-		}
-
-	}
-	
-	static class MockInputStream extends InputStream {
-
-		static final int normal = 0;
-
-		static final int exception = 1;
-
-		static final int runtimeException = 2;
-
-		int result = normal;
-
-		InputStream wrapper;
-
-		public void setResult(int i) {
-			result = i;
-		}
-
-		private void checkException() throws IOException {
-			switch (result) {
-			case normal:
-				return;
-			case exception:
-				throw new IOException("test");
-			case runtimeException:
-				throw new RuntimeException("test");
-			}
-		}
-
-		public MockInputStream(InputStream in) {
-			wrapper = in;
-		}
-
-		public int read() throws IOException {
-			checkException();
-			return wrapper.read();
-		}
-	}
-
-	static class MockPreferences extends Preferences {
-
-		public MockPreferences() {
-			super();
-		}
-
-		public String absolutePath() {
-			return null;
-		}
-
-		public String[] childrenNames() throws BackingStoreException {
-			return null;
-		}
+    MockSecurityManager manager = new MockSecurityManager();
+
+    MockInputStream stream = null;
+    
+    final static String longKey;
+    
+    final static String longValue;
+
+    InputStream in;
+    static {
+        StringBuffer key = new StringBuffer(Preferences.MAX_KEY_LENGTH);
+        for (int i = 0; i < Preferences.MAX_KEY_LENGTH; i++) {
+            key.append('a');
+        }
+        longKey = key.toString();
+        
+        StringBuffer value = new StringBuffer(Preferences.MAX_VALUE_LENGTH);
+        for (int i = 0; i < Preferences.MAX_VALUE_LENGTH; i++) {
+            value.append('a');
+        }
+        longValue = value.toString();
+    }
+
+    /*
+     * @see TestCase#setUp()
+     */
+    protected void setUp() throws Exception {
+        super.setUp();
+        in = new ByteArrayInputStream(
+                "<!DOCTYPE preferences SYSTEM \"http://java.sun.com/dtd/preferences.dtd\"><preferences><root type=\"user\"><map></map></root></preferences>"
+                        .getBytes("UTF-8"));
+        stream = new MockInputStream(in);
+    }
+
+    /*
+     * @see TestCase#tearDown()
+     */
+    protected void tearDown() throws Exception {
+        super.tearDown();
+        stream.close();
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "systemNodeForPackage",
+          methodArgs = {java.lang.Class.class}
+        )
+    })
+    public void testSystemNodeForPackage() throws BackingStoreException {
+        Preferences p = null;
+        try {
+            p = Preferences.systemNodeForPackage(Object.class);
+        } catch (SecurityException e) {
+            // may be caused by absence of privileges on the underlying OS
+            return;
+        }
+        assertEquals("/java/lang", p.absolutePath());
+        assertTrue(p instanceof AbstractPreferences);
+        Preferences root = Preferences.systemRoot();
+        Preferences parent = root.node("java");
+        assertSame(parent, p.parent());
+        assertFalse(p.isUserNode());
+        assertEquals("lang", p.name());
+        assertEquals("System Preference Node: " + p.absolutePath(), p
+                .toString());
+        try {
+            assertEquals(0, p.childrenNames().length);
+        } catch (BackingStoreException e) {
+            // could be thrown according to specification
+        }
+        try {
+            assertEquals(0, p.keys().length);
+        } catch (BackingStoreException e) {
+            // could be thrown according to specification
+        }
+
+        try {
+            p = Preferences.userNodeForPackage(null);
+            fail("NullPointerException has not been thrown");
+        } catch (NullPointerException e) {
+            // expected
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "SecurityException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "systemRoot",
+          methodArgs = {}
+        )
+    })
+    public void testSystemRoot() throws BackingStoreException {
+        Preferences p = Preferences.systemRoot();
+        assertTrue(p instanceof AbstractPreferences);
+        assertEquals("/", p.absolutePath());
+        assertSame(null, p.parent());
+        assertFalse(p.isUserNode());
+        assertEquals("", p.name());
+        assertEquals("System Preference Node: " + p.absolutePath(), p
+                .toString());
+        // assertEquals(0, p.childrenNames().length);
+        // assertEquals(0, p.keys().length);
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Checks constant values",
+      targets = {
+        @TestTarget(
+          methodName = "!Constants",
+          methodArgs = {}
+        )
+    })
+    public void testConsts() {
+        assertEquals(80, Preferences.MAX_KEY_LENGTH);
+        assertEquals(80, Preferences.MAX_NAME_LENGTH);
+        assertEquals(8192, Preferences.MAX_VALUE_LENGTH);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "SecurityException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "userNodeForPackage",
+          methodArgs = {java.lang.Class.class}
+        )
+    })
+    public void testUserNodeForPackage() throws BackingStoreException {
+        Preferences p = Preferences.userNodeForPackage(Object.class);
+        assertEquals("/java/lang", p.absolutePath());
+        assertTrue(p instanceof AbstractPreferences);
+        Preferences root = Preferences.userRoot();
+        Preferences parent = root.node("java");
+        assertSame(parent, p.parent());
+        assertTrue(p.isUserNode());
+        assertEquals("lang", p.name());
+        assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
+        assertEquals(0, p.childrenNames().length);
+        assertEquals(0, p.keys().length);
+
+        try {
+            p = Preferences.userNodeForPackage(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "SecurityException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "userRoot",
+          methodArgs = {}
+        )
+    })
+    public void testUserRoot() throws BackingStoreException {
+        Preferences p = Preferences.userRoot();
+        assertTrue(p instanceof AbstractPreferences);
+        assertEquals("/", p.absolutePath());
+        assertSame(null, p.parent());
+        assertTrue(p.isUserNode());
+        assertEquals("", p.name());
+        assertEquals("User Preference Node: " + p.absolutePath(), p.toString());
+        // assertEquals(0, p.childrenNames().length);
+        // assertEquals(p.keys().length, 0);
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "SecurityException & IOException checking missed.",
+      targets = {
+        @TestTarget(
+          methodName = "importPreferences",
+          methodArgs = {java.io.InputStream.class}
+        )
+    })
+    public void _testImportPreferences() throws Exception {
+        Preferences prefs = null;
+        try {
+            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
+            // assertEquals(0, prefs.childrenNames().length);
+            // assertFalse(prefs.nodeExists("mock/child/grandson"));
+
+            prefs.put("prefskey", "oldvalue");
+            prefs.put("prefskey2", "oldvalue2");
+            in = getClass().getResourceAsStream("/prefs/java/util/prefs/userprefs.xml");
+            Preferences.importPreferences(in);
+
+            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
+            assertEquals(1, prefs.childrenNames().length);
+            assertTrue(prefs.nodeExists("mock/child/grandson"));
+            assertEquals("newvalue", prefs.get("prefskey", null));
+            assertEquals("oldvalue2", prefs.get("prefskey2", null));
+            assertEquals("newvalue3", prefs.get("prefskey3", null));
+
+            in = PreferencesTest.class
+                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-badform.xml");
+            try {
+                Preferences.importPreferences(in);
+                fail();
+            } catch (InvalidPreferencesFormatException e) {
+            }
+
+            in = PreferencesTest.class
+                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-badtype.xml");
+            try {
+                Preferences.importPreferences(in);
+                fail();
+            } catch (InvalidPreferencesFormatException e) {
+            }
+
+    //        in = PreferencesTest.class
+    //                .getResourceAsStream("/prefs/java/util/prefs/userprefs-badencoding.xml");
+    //        try {
+    //            Preferences.importPreferences(in);
+    //            fail();
+    //        } catch (InvalidPreferencesFormatException e) {
+    //        }
+
+            in = PreferencesTest.class
+                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-higherversion.xml");
+            try {
+                Preferences.importPreferences(in);
+                fail();
+            } catch (InvalidPreferencesFormatException e) {
+            }
+
+            in = PreferencesTest.class
+                    .getResourceAsStream("/prefs/java/util/prefs/userprefs-ascii.xml");
+            Preferences.importPreferences(in);
+            prefs = Preferences.userNodeForPackage(PreferencesTest.class);
+        } finally {
+            try {
+                prefs = Preferences.userRoot().node("tests");
+                prefs.removeNode();
+            } catch (Exception e) {
+            }
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "Test for Exceptions only.",
+      targets = {
+        @TestTarget(
+          methodName = "importPreferences",
+          methodArgs = {java.io.InputStream.class}
+        )
+    })
+    public void testImportPreferencesException() throws Exception {
+        try {
+            Preferences.importPreferences(null);
+            fail();
+        } catch (MalformedURLException e) {
+        }
+
+        byte[] source = new byte[0];
+        InputStream in = new ByteArrayInputStream(source);
+        try {
+            Preferences.importPreferences(in);
+            fail();
+        } catch (InvalidPreferencesFormatException e) {
+        }
+
+        stream.setResult(MockInputStream.exception);
+        try {
+            Preferences.importPreferences(stream);
+            fail();
+        } catch (IOException e) {
+        }
+
+        stream.setResult(MockInputStream.runtimeException);
+        try {
+            Preferences.importPreferences(stream);
+            fail();
+        } catch (RuntimeException e) {
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.PARTIAL_OK,
+      purpose = "SecurityException checking.",
+      targets = {
+        @TestTarget(
+          methodName = "userRoot",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "systemRoot",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "userNodeForPackage",
+          methodArgs = {java.lang.Class.class}
+        ), @TestTarget(
+          methodName = "systemNodeForPackage",
+          methodArgs = {java.lang.Class.class}
+        ), @TestTarget(
+          methodName = "importPreferences",
+          methodArgs = {java.io.InputStream.class}
+        )
+    })
+    public void testSecurity() throws InvalidPreferencesFormatException,
+            IOException {
+        try {
+            manager.install();
+            try {
+                Preferences.userRoot();
+                fail();
+            } catch (SecurityException e) {
+            }
+            try {
+                Preferences.systemRoot();
+                fail();
+            } catch (SecurityException e) {
+            }
+            try {
+                Preferences.userNodeForPackage(null);
+                fail();
+            } catch (SecurityException e) {
+            }
+
+            try {
+                Preferences.systemNodeForPackage(null);
+                fail();
+            } catch (SecurityException e) {
+            }
+
+            try {
+                Preferences.importPreferences(stream);
+                fail();
+            } catch (SecurityException e) {
+            }
+        } finally {
+            manager.restoreDefault();
+        }
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Test for abstract methods.",
+      targets = {
+        @TestTarget(
+          methodName = "absolutePath",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "exportNode",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "exportSubtree",
+          methodArgs = {java.io.OutputStream.class}
+        ), @TestTarget(
+          methodName = "flush",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "getBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "getByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "getFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "getDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        ), @TestTarget(
+          methodName = "getInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "getLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "isUserNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "name",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "node",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "nodeExists",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "parent",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        ), @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        ), @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        ), @TestTarget(
+          methodName = "putDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        ), @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        ), @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        ), @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        ), @TestTarget(
+          methodName = "remove",
+          methodArgs = {java.lang.String.class}
+        ), @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "addNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "addPreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        ), @TestTarget(
+          methodName = "removeNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        ), @TestTarget(
+          methodName = "removePreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        ), @TestTarget(
+          methodName = "sync",
+          methodArgs = {}
+        ), @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
+    public void testAbstractMethods() {
+        Preferences p = new MockPreferences();
+        p.absolutePath();
+        try {
+            p.childrenNames();
+        } catch (BackingStoreException e4) {
+        }
+        try {
+            p.clear();
+        } catch (BackingStoreException e5) {
+        }
+        try {
+            p.exportNode(null);
+        } catch (IOException e6) {
+        } catch (BackingStoreException e6) {
+        }
+        try {
+            p.exportSubtree(null);
+        } catch (IOException e7) {
+        } catch (BackingStoreException e7) {
+        }
+        try {
+            p.flush();
+        } catch (BackingStoreException e8) {
+        }
+        p.get(null, null);
+        p.getBoolean(null, false);
+        p.getByteArray(null, null);
+        p.getFloat(null, 0.1f);
+        p.getDouble(null, 0.1);
+        p.getInt(null, 1);
+        p.getLong(null, 1l);
+        p.isUserNode();
+        try {
+            p.keys();
+        } catch (BackingStoreException e) {
+        }
+        p.name();
+        p.node(null);
+        try {
+            p.nodeExists(null);
+        } catch (BackingStoreException e1) {
+        }
+        p.parent();
+        p.put(null, null);
+        p.putBoolean(null, false);
+        p.putByteArray(null, null);
+        p.putDouble(null, 1);
+        p.putFloat(null, 1f);
+        p.putInt(null, 1);
+        p.putLong(null, 1l);
+        p.remove(null);
+        try {
+            p.removeNode();
+        } catch (BackingStoreException e2) {
+        }
+        p.addNodeChangeListener(null);
+        p.addPreferenceChangeListener(null);
+        p.removeNodeChangeListener(null);
+        p.removePreferenceChangeListener(null);
+        try {
+            p.sync();
+        } catch (BackingStoreException e3) {
+        }
+        p.toString();
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "Preferences",
+          methodArgs = {}
+        )
+    })
+    public void testConstructor() {
+        MockPreferences mp = new MockPreferences();
+        assertEquals(mp.getClass(), MockPreferences.class);
+    }
+
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "Check existed implementation",
+      targets = {
+        @TestTarget(
+          methodName = "toString",
+          methodArgs = {}
+        )
+    })
+    public void testToString() {
+        Preferences p1 = Preferences.userNodeForPackage(Preferences.class);
+        assertNotNull(p1.toString());
+
+        Preferences p2 = Preferences.systemRoot();
+        assertNotNull(p2.toString());
+
+        Preferences p3 = Preferences.userRoot();
+        assertNotNull(p3.toString());
+    }
+    /**
+     * @test java.util.prefs.Preferences#absolutePath()
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "absolutePath",
+          methodArgs = {}
+        )
+    })
+    public void testAbsolutePath() {
+        Preferences p = Preferences.userNodeForPackage(Preferences.class);
+        assertEquals("/java/util/prefs", p.absolutePath());
+
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#childrenNames()
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "childrenNames",
+          methodArgs = {}
+        )
+    })
+    public void testChildrenNames() throws BackingStoreException {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+
+        Preferences child1 = pref.node("child1");
+
+        pref.node("child2");
+        pref.node("child3");
+        child1.node("subchild1");
+
+        assertSame(pref, child1.parent());
+        assertEquals(4, pref.childrenNames().length);
+        assertEquals("child1", pref.childrenNames()[0]);
+        assertEquals(1, child1.childrenNames().length);
+        assertEquals("subchild1", child1.childrenNames()[0]);
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#clear()
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "clear",
+          methodArgs = {}
+        )
+    })
+    public void testClear() throws BackingStoreException {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        pref.put("testClearKey", "testClearValue");
+        pref.put("testClearKey1", "testClearValue1");
+        assertEquals("testClearValue", pref.get("testClearKey", null));
+        assertEquals("testClearValue1", pref.get("testClearKey1", null));
+        pref.clear();
+        assertNull(pref.get("testClearKey", null));
+        assertNull(pref.get("testClearKey1", null));
+    }    
+
+    /**
+     * @test java.util.prefs.Preferences#get(String key, String def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "get",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testGet() throws BackingStoreException {
+        Preferences root = Preferences.userNodeForPackage(Preferences.class);
+        Preferences pref = root.node("mock");
+        assertNull(pref.get("", null));
+        assertEquals("default", pref.get("key", "default"));
+        assertNull(pref.get("key", null));
+        pref.put("testGetkey", "value");
+        assertNull(pref.get("testGetKey", null));
+        assertEquals("value", pref.get("testGetkey", null));
+
+        try {
+            pref.get(null, "abc");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.get("", "abc");
+        pref.get("key", null);
+        pref.get("key", "");
+        pref.putFloat("floatKey", 1.0f);
+        assertEquals("1.0", pref.get("floatKey", null));
+
+        pref.removeNode();
+        try {
+            pref.get("key", "abc");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+        try {
+            pref.get(null, "abc");
+            fail();
+        } catch (NullPointerException e) {
+        }
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#getBoolean(String key, boolean def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        )
+    })
+    public void testGetBoolean() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getBoolean(null, false);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetBooleanKey", "false");
+        pref.put("testGetBooleanKey2", "value");
+        assertFalse(pref.getBoolean("testGetBooleanKey", true));
+        assertTrue(pref.getBoolean("testGetBooleanKey2", true));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#getByteArray(String key, byte[] def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        )
+    })
+    public void testGetByteArray() throws UnsupportedEncodingException {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        byte[] b64Array = new byte[] { 0x59, 0x57, 0x4a, 0x6a };// BASE64
+
+        pref.put("testGetByteArrayKey", "abc=");
+        pref.put("testGetByteArrayKey2", new String(b64Array));
+        pref.put("invalidKey", "<>?");
+        assertTrue(Arrays.equals(new byte[] { 105, -73 }, pref.getByteArray(
+                "testGetByteArrayKey", new byte[0])));
+        assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
+                .getByteArray("testGetByteArrayKey2", new byte[0])));
+        assertTrue(Arrays.equals(new byte[0], pref.getByteArray("invalidKey",
+                new byte[0])));
+
+        pref.putByteArray("testGetByteArrayKey3", b64Array);
+        pref.putByteArray("testGetByteArrayKey4", "abc".getBytes());
+        assertTrue(Arrays.equals(b64Array, pref.getByteArray(
+                "testGetByteArrayKey3", new byte[0])));
+        assertTrue(Arrays.equals("abc".getBytes(), pref.getByteArray(
+                "testGetByteArrayKey4", new byte[0])));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#getDouble(String key, double def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        )
+    })
+    public void testGetDouble() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getDouble(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetDoubleKey", "1");
+        pref.put("testGetDoubleKey2", "value");
+        pref.putDouble("testGetDoubleKey3", 1);
+        pref.putInt("testGetDoubleKey4", 1);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey", 0.0), 0);
+        assertEquals(0.0, pref.getDouble("testGetDoubleKey2", 0.0), 0);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey3", 0.0), 0);
+        assertEquals(1.0, pref.getDouble("testGetDoubleKey4", 0.0), 0);
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#getFloat(String key, float def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        )
+    })
+    public void testGetFloat() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getFloat(null, 0f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.put("testGetFloatKey", "1");
+        pref.put("testGetFloatKey2", "value");
+        assertEquals(1f, pref.getFloat("testGetFloatKey", 0f), 0); //$NON-NLS-1$
+        assertEquals(0f, pref.getFloat("testGetFloatKey2", 0f), 0);
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#getInt(String key, int def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getInt",
+          methodArgs = {java.lang.String.class, int.class}
+        )
+    })
+    public void testGetInt() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getInt(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetIntKey", "1");
+        pref.put("testGetIntKey2", "value");
+        assertEquals(1, pref.getInt("testGetIntKey", 0));
+        assertEquals(0, pref.getInt("testGetIntKey2", 0));
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#getLong(String key, long def)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "getLong",
+          methodArgs = {java.lang.String.class, long.class}
+        )
+    })
+    public void testGetLong() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.getLong(null, 0);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.put("testGetLongKey", "1");
+        pref.put("testGetLongKey2", "value");
+        assertEquals(1, pref.getInt("testGetLongKey", 0));
+        assertEquals(0, pref.getInt("testGetLongKey2", 0));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#isUserNode()
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "isUserNode",
+          methodArgs = {}
+        )
+    })
+    public void testIsUserNode() {
+        Preferences pref1 = Preferences.userNodeForPackage(Preferences.class);
+        assertTrue(pref1.isUserNode());
+
+        Preferences pref2 = Preferences.systemNodeForPackage(Preferences.class);
+        assertFalse(pref2.isUserNode());
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#keys()
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Exceptions checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "keys",
+          methodArgs = {}
+        )
+    })
+    public void testKeys() throws BackingStoreException {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        pref.clear();
+        
+        pref.put("key0", "value");
+        pref.put("key1", "value1");
+        pref.put("key2", "value2");
+        pref.put("key3", "value3");
+
+        String[] keys = pref.keys();
+        assertEquals(4, keys.length);
+        for (int i = 0; i < keys.length; i++) {
+            assertEquals(0, keys[i].indexOf("key"));
+            assertEquals(4, keys[i].length());
+        }
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#name()
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "name",
+          methodArgs = {}
+        )
+    })
+    public void testName() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        Preferences child = pref.node("mock");
+        assertEquals("mock", child.name());
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#node(String pathName)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "node",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testNode() throws BackingStoreException {
+        StringBuffer name = new StringBuffer(Preferences.MAX_NAME_LENGTH);
+        for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) {
+            name.append('a');
+        }
+        String longName = name.toString();
+        
+        Preferences root = Preferences.userRoot();
+        Preferences parent = Preferences
+                .userNodeForPackage(Preferences.class);
+        Preferences pref = parent.node("mock");
+        
+        try {
+            pref.node(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.node("/java/util/prefs/");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.node("/java//util/prefs");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.node(longName + "a");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        assertNotNull(pref.node(longName));
+
+        assertSame(root, pref.node("/"));
+
+        Preferences prefs = pref.node("/java/util/prefs");
+        assertSame(prefs, parent);
+
+        assertSame(pref, pref.node(""));
+
+        if (!(pref instanceof MockAbstractPreferences)) {
+            return;
+        }
+        MockAbstractPreferences child = (MockAbstractPreferences) ((MockAbstractPreferences) pref)
+                .publicChildSpi("child");
+        assertSame(child, pref.node("child"));
+
+        Preferences child2 = pref.node("child2");
+        assertSame(child2, ((MockAbstractPreferences) pref)
+                .publicChildSpi("child2"));
+
+        Preferences grandchild = pref.node("child/grandchild");
+        assertSame(grandchild, child.childSpi("grandchild"));
+        assertSame(grandchild, child.cachedChildrenImpl()[0]);
+        grandchild.removeNode();
+        assertNotSame(grandchild, pref.node("child/grandchild"));
+
+        grandchild = pref.node("child3/grandchild");
+        AbstractPreferences[] childs = ((MockAbstractPreferences) pref)
+                .cachedChildrenImpl();
+        Preferences child3 = child;
+        for (int i = 0; i < childs.length; i++) {
+            if (childs[i].name().equals("child3")) {
+                child3 = childs[i];
+                break;
+            }
+        }
+        assertSame(child3, grandchild.parent());
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#nodeExists(String pathName)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException & BackingStoreException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "nodeExists",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testNodeExists() throws BackingStoreException {
+
+        Preferences parent = Preferences
+                .userNodeForPackage(Preferences.class);
+        Preferences pref = parent.node("mock");
+        
+        try {
+            pref.nodeExists(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.nodeExists("/java/util/prefs/");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.nodeExists("/java//util/prefs");
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        assertTrue(pref.nodeExists("/"));
+
+        assertTrue(pref.nodeExists("/java/util/prefs"));
+
+        assertTrue(pref.nodeExists(""));
+
+        assertFalse(pref.nodeExists("child"));
+        Preferences grandchild = pref.node("child/grandchild");
+        assertTrue(pref.nodeExists("child"));
+        assertTrue(pref.nodeExists("child/grandchild"));
+        grandchild.removeNode();
+        assertTrue(pref.nodeExists("child"));
+        assertFalse(pref.nodeExists("child/grandchild"));
+        assertFalse(grandchild.nodeExists(""));
+
+        assertFalse(pref.nodeExists("child2/grandchild"));
+        pref.node("child2/grandchild");
+        assertTrue(pref.nodeExists("child2/grandchild"));
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#parent()
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "parent",
+          methodArgs = {}
+        )
+    })
+    public void testParent() {
+        Preferences parent = Preferences
+                .userNodeForPackage(Preferences.class);
+        Preferences pref = parent.node("mock");
+        
+        assertSame(parent, pref.parent());
+        
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#put(String key, String value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "put",
+          methodArgs = {java.lang.String.class, java.lang.String.class}
+        )
+    })
+    public void testPut() throws BackingStoreException {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        pref.put("", "emptyvalue");
+        assertEquals("emptyvalue", pref.get("", null));
+        pref.put("testPutkey", "value1");
+        assertEquals("value1", pref.get("testPutkey", null));
+        pref.put("testPutkey", "value2");
+        assertEquals("value2", pref.get("testPutkey", null));
+
+        pref.put("", "emptyvalue");
+        assertEquals("emptyvalue", pref.get("", null));
+
+        try {
+            pref.put(null, "value");
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.put("key", null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.put(longKey, longValue);
+        try {
+            pref.put(longKey + 1, longValue);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.put(longKey, longValue + 1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        pref.removeNode();
+        try {
+            pref.put(longKey, longValue + 1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        try {
+            pref.put(longKey, longValue);
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#putBoolean(String key, boolean value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putBoolean",
+          methodArgs = {java.lang.String.class, boolean.class}
+        )
+    })
+    public void testPutBoolean() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putBoolean(null, false);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putBoolean(longKey, false);
+        try {
+            pref.putBoolean(longKey + "a", false);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putBoolean("testPutBooleanKey", false);
+        assertEquals("false", pref.get("testPutBooleanKey", null));
+        assertFalse(pref.getBoolean("testPutBooleanKey", true));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#putDouble(String key, double value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putDouble",
+          methodArgs = {java.lang.String.class, double.class}
+        )
+    })
+    public void testPutDouble() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putDouble(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putDouble(longKey, 3);
+        try {
+            pref.putDouble(longKey + "a", 3);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putDouble("testPutDoubleKey", 3);
+        assertEquals("3.0", pref.get("testPutDoubleKey", null));
+        assertEquals(3, pref.getDouble("testPutDoubleKey", 0), 0);
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#putFloat(String key, float value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putFloat",
+          methodArgs = {java.lang.String.class, float.class}
+        )
+    })
+    public void testPutFloat() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putFloat(null, 3f);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putFloat(longKey, 3f);
+        try {
+            pref.putFloat(longKey + "a", 3f);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putFloat("testPutFloatKey", 3f);
+        assertEquals("3.0", pref.get("testPutFloatKey", null));
+        assertEquals(3f, pref.getFloat("testPutFloatKey", 0), 0);
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#putInt(String key, int value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putInt",
+          methodArgs = {java.lang.String.class, int.class}
+        )
+    })
+    public void testPutInt() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putInt(null, 3);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putInt(longKey, 3);
+        try {
+            pref.putInt(longKey + "a", 3);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putInt("testPutIntKey", 3);
+        assertEquals("3", pref.get("testPutIntKey", null));
+        assertEquals(3, pref.getInt("testPutIntKey", 0));
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#putLong(String key, long value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putLong",
+          methodArgs = {java.lang.String.class, long.class}
+        )
+    })
+    public void testPutLong() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putLong(null, 3L);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        pref.putLong(longKey, 3L);
+        try {
+            pref.putLong(longKey + "a", 3L);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.putLong("testPutLongKey", 3L);
+        assertEquals("3", pref.get("testPutLongKey", null));
+        assertEquals(3L, pref.getLong("testPutLongKey", 0));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#putByteArray(String key, byte[] value)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "putByteArray",
+          methodArgs = {java.lang.String.class, byte[].class}
+        )
+    })
+    public void testPutByteArray() {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        try {
+            pref.putByteArray(null, new byte[0]);
+            fail();
+        } catch (NullPointerException e) {
+        }
+        try {
+            pref.putByteArray("testPutByteArrayKey4", null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.putByteArray(longKey, new byte[0]);
+        try {
+            pref.putByteArray(longKey + "a", new byte[0]);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        byte[] longArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.74)];
+        byte[] longerArray = new byte[(int) (Preferences.MAX_VALUE_LENGTH * 0.75) + 1];
+        pref.putByteArray(longKey, longArray);
+        try {
+            pref.putByteArray(longKey, longerArray);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+        pref.putByteArray("testPutByteArrayKey", new byte[0]);
+        assertEquals("", pref.get("testPutByteArrayKey", null));
+        assertTrue(Arrays.equals(new byte[0], pref.getByteArray(
+                "testPutByteArrayKey", null)));
+
+        pref.putByteArray("testPutByteArrayKey3", new byte[] { 'a', 'b', 'c' });
+        assertEquals("YWJj", pref.get("testPutByteArrayKey3", null));
+        assertTrue(Arrays.equals(new byte[] { 'a', 'b', 'c' }, pref
+                .getByteArray("testPutByteArrayKey3", null)));
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#remove(String key)
+     *
+     */
+@TestInfo(
+      level = TestLevel.COMPLETE,
+      purpose = "",
+      targets = {
+        @TestTarget(
+          methodName = "remove",
+          methodArgs = {java.lang.String.class}
+        )
+    })
+    public void testRemove() throws BackingStoreException {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        pref.remove("key");
+
+        pref.put("key", "value");
+        assertEquals("value", pref.get("key", null));
+        pref.remove("key");
+        assertNull(pref.get("key", null));
+
+        pref.remove("key");
+
+        try {
+            pref.remove(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        pref.removeNode();
+        try {
+            pref.remove("key");
+            fail();
+        } catch (IllegalStateException e) {
+        }
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#removeNode()
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Exceptions checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "removeNode",
+          methodArgs = {}
+        )
+    })
+    public void testRemoveNode() throws BackingStoreException {
+        Preferences pref = Preferences
+        .userNodeForPackage(Preferences.class);
+        Preferences child = pref.node("child");
+        Preferences child1 = pref.node("child1");
+        Preferences grandchild = child.node("grandchild");
+
+        pref.removeNode();
+
+        assertFalse(child.nodeExists(""));
+        assertFalse(child1.nodeExists(""));
+        assertFalse(grandchild.nodeExists(""));
+        assertFalse(pref.nodeExists(""));
+    }
+    
+    
+    /**
+     * @test java.util.prefs.Preferences#addNodeChangeListener(NodeChangeListener ncl)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Only NullPointerException checked, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "addNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        )
+    })
+    public void _testAddNodeChangeListener() throws BackingStoreException {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.addNodeChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        Preferences child1 = null;
+        Preferences child2 = null;
+        Preferences child3 = null;
+        
+        MockNodeChangeListener nl = null;
+        // To get existed node doesn't create the change event
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock1");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+            child2 = pref.node("mock1");
+            assertEquals(0, nl.getAdded());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            child1.removeNode();
+        }
+        // same listener can be added twice, and must be removed twice
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock2");
+            assertEquals(2, nl.getAdded());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            pref.removeNodeChangeListener(nl);
+            child1.removeNode();
+        }
+        // test remove event
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock3");
+            child1.removeNode();
+            assertEquals(1, nl.getRemoved());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+        }
+        // test remove event with two listeners
+        try {
+            nl = new MockNodeChangeListener();
+            pref.addNodeChangeListener(nl);
+            pref.addNodeChangeListener(nl);
+            child1 = pref.node("mock6");
+            child1.removeNode();
+            assertEquals(2, nl.getRemoved());
+            nl.reset();
+        } finally {
+            pref.removeNodeChangeListener(nl);
+            pref.removeNodeChangeListener(nl);
+        }
+        // test add/remove indirect children, or remove several children at the
+        // same time
+        try {
+            nl = new MockNodeChangeListener();
+            child1 = pref.node("mock4");
+            child1.addNodeChangeListener(nl);
+            child2 = pref.node("mock4/mock5");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+            child3 = pref.node("mock4/mock5/mock6");
+            assertEquals(0, nl.getAdded());
+            nl.reset();
+
+            child3.removeNode();
+            assertEquals(0, nl.getRemoved());
+            nl.reset();
+
+            child3 = pref.node("mock4/mock7");
+            assertEquals(1, nl.getAdded());
+            nl.reset();
+
+            child1.removeNode();
+            assertEquals(2, nl.getRemoved());
+            nl.reset();
+        } finally {
+            try {
+                child1.removeNode();
+            } catch (Exception e) {
+            }
+        }
+
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#addPreferenceChangeListener(PreferenceChangeListener pcl)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "Only NullPointerException checked, but method is abstract, probably it is OK",
+      targets = { 
+        @TestTarget(
+          methodName = "addPreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        )
+    })
+    public void _testAddPreferenceChangeListener() {
+        
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        MockPreferenceChangeListener pl = null;
+        
+        // TODO: start from here
+        try {
+            pref.addPreferenceChangeListener(null);
+            fail();
+        } catch (NullPointerException e) {
+        }
+
+        // To get existed node doesn't create the change event
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.putInt("mock1", 123);
+            assertEquals(1, pl.getChanged());
+            pref.putLong("long_key", Long.MAX_VALUE);
+            assertEquals(2, pl.getChanged());
+            pl.reset();
+            try {
+                pref.clear();
+                assertEquals(2, pl.getChanged());
+            } catch(BackingStoreException bse) {
+                pl.reset();
+                fail("BackingStoreException is thrown");
+            }
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+            //child1.removeNode();
+        }
+                      
+        // same listener can be added twice, and must be removed twice
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.addPreferenceChangeListener(pl);
+            pref.putFloat("float_key", Float.MIN_VALUE);
+            assertEquals(2, pl.getChanged());
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+            pref.removePreferenceChangeListener(pl);
+
+        }
+        // test remove event
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.putDouble("double_key", Double.MAX_VALUE);
+            assertEquals(1, pl.getChanged());
+            try {
+                pref.clear();
+                assertEquals(3, pl.getChanged());
+            } catch(BackingStoreException bse) {
+                fail("BackingStoreException is thrown");
+            }
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+        }
+        // test remove event with two listeners
+        try {
+            pl = new MockPreferenceChangeListener();
+            pref.addPreferenceChangeListener(pl);
+            pref.addPreferenceChangeListener(pl);
+            pref.putByteArray("byte_array_key", new byte [] {1 ,2 , 3});
+            try {
+                pref.clear();
+                assertEquals(4, pl.getChanged());
+            } catch(BackingStoreException bse) {
+                fail("BackingStoreException is thrown");
+            }
+            pl.reset();
+        } finally {
+            pref.removePreferenceChangeListener(pl);
+            pref.removePreferenceChangeListener(pl);
+        }
+
+    }
+    
+    /**
+     * @test java.util.prefs.Preferences#removeNodeChangeListener(NodeChangeListener ncl)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "removeNodeChangeListener",
+          methodArgs = {java.util.prefs.NodeChangeListener.class}
+        )
+    })
+    public void testRemoveNodeChangeListener() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.removeNodeChangeListener(null);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        MockNodeChangeListener l1 = new MockNodeChangeListener();
+        MockNodeChangeListener l2 = new MockNodeChangeListener();
+        pref.addNodeChangeListener(l1);
+        pref.addNodeChangeListener(l1);
+
+        pref.removeNodeChangeListener(l1);
+        pref.removeNodeChangeListener(l1);
+        try {
+            pref.removeNodeChangeListener(l1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        try {
+            pref.removeNodeChangeListener(l2);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+    }
+
+    /**
+     * @test java.util.prefs.Preferences#removePreferenceChangeListener(PreferenceChangeListener pcl)
+     *
+     */
+@TestInfo(
+      level = TestLevel.PARTIAL,
+      purpose = "IllegalStateException checking missed, but method is abstract, probably it is OK",
+      targets = {
+        @TestTarget(
+          methodName = "removePreferenceChangeListener",
+          methodArgs = {java.util.prefs.PreferenceChangeListener.class}
+        )
+    })
+    public void testRemovePreferenceChangeListener() {
+        Preferences pref = Preferences.userNodeForPackage(Preferences.class);
+        try {
+            pref.removePreferenceChangeListener(null);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        MockPreferenceChangeListener l1 = new MockPreferenceChangeListener();
+        MockPreferenceChangeListener l2 = new MockPreferenceChangeListener();
+        pref.addPreferenceChangeListener(l1);
+        pref.addPreferenceChangeListener(l1);
+        try {
+            pref.removePreferenceChangeListener(l2);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+        pref.removePreferenceChangeListener(l1);
+        pref.removePreferenceChangeListener(l1);
+        try {
+            pref.removePreferenceChangeListener(l1);
+            fail();
+        } catch (IllegalArgumentException e) {
+        }
+
+    }
+    
+    static class MockInputStream extends InputStream {
+
+        static final int normal = 0;
+
+        static final int exception = 1;
+
+        static final int runtimeException = 2;
+
+        int result = normal;
+
+        InputStream wrapper;
+
+        public void setResult(int i) {
+            result = i;
+        }
+
+        private void checkException() throws IOException {
+            switch (result) {
+            case normal:
+                return;
+            case exception:
+                throw new IOException("test");
+            case runtimeException:
+                throw new RuntimeException("test");
+            }
+        }
+
+        public MockInputStream(InputStream in) {
+            wrapper = in;
+        }
+
+        public int read() throws IOException {
+            checkException();
+            return wrapper.read();
+        }
+    }
+
+    static class MockPreferences extends Preferences {
+
+        public MockPreferences() {
+            super();
+        }
+
+        public String absolutePath() {
+            return null;
+        }
+
+        public String[] childrenNames() throws BackingStoreException {
+            return null;
+        }
 
-		public void clear() throws BackingStoreException {
-		}
+        public void clear() throws BackingStoreException {
+        }
 
-		public void exportNode(OutputStream ostream) throws IOException,
-				BackingStoreException {
-		}
+        public void exportNode(OutputStream ostream) throws IOException,
+                BackingStoreException {
+        }
 
-		public void exportSubtree(OutputStream ostream) throws IOException,
-				BackingStoreException {
-		}
+        public void exportSubtree(OutputStream ostream) throws IOException,
+                BackingStoreException {
+        }
 
-		public void flush() throws BackingStoreException {
-		}
+        public void flush() throws BackingStoreException {
+        }
 
-		public String get(String key, String deflt) {
-			return null;
-		}
+        public String get(String key, String deflt) {
+            return null;
+        }
 
-		public boolean getBoolean(String key, boolean deflt) {
-			return false;
-		}
+        public boolean getBoolean(String key, boolean deflt) {
+            return false;
+        }
 
-		public byte[] getByteArray(String key, byte[] deflt) {
-			return null;
-		}
+        public byte[] getByteArray(String key, byte[] deflt) {
+            return null;
+        }
 
-		public double getDouble(String key, double deflt) {
-			return 0;
-		}
+        public double getDouble(String key, double deflt) {
+            return 0;
+        }
 
-		public float getFloat(String key, float deflt) {
-			return 0;
-		}
+        public float getFloat(String key, float deflt) {
+            return 0;
+        }
 
-		public int getInt(String key, int deflt) {
-			return 0;
-		}
+        public int getInt(String key, int deflt) {
+            return 0;
+        }
 
-		public long getLong(String key, long deflt) {
-			return 0;
-		}
+        public long getLong(String key, long deflt) {
+            return 0;
+        }
 
-		public boolean isUserNode() {
-			return false;
-		}
+        public boolean isUserNode() {
+            return false;
+        }
 
-		public String[] keys() throws BackingStoreException {
-			return null;
-		}
+        public String[] keys() throws BackingStoreException {
+            return null;
+        }
 
-		public String name() {
-			return null;
-		}
+        public String name() {
+            return null;
+        }
 
-		public Preferences node(String name) {
-			return null;
-		}
+        public Preferences node(String name) {
+            return null;
+        }
 
-		public boolean nodeExists(String name) throws BackingStoreException {
-			return false;
-		}
+        public boolean nodeExists(String name) throws BackingStoreException {
+            return false;
+        }
 
-		public Preferences parent() {
-			return null;
-		}
+        public Preferences parent() {
+            return null;
+        }
 
-		public void put(String key, String value) {
+        public void put(String key, String value) {
 
-		}
+        }
 
-		public void putBoolean(String key, boolean value) {
+        public void putBoolean(String key, boolean value) {
 
-		}
+        }
 
-		public void putByteArray(String key, byte[] value) {
+        public void putByteArray(String key, byte[] value) {
 
-		}
+        }
 
-		public void putDouble(String key, double value) {
+        public void putDouble(String key, double value) {
 
-		}
+        }
 
-		public void putFloat(String key, float value) {
+        public void putFloat(String key, float value) {
 
-		}
+        }
 
-		public void putInt(String key, int value) {
+        public void putInt(String key, int value) {
 
-		}
+        }
 
-		public void putLong(String key, long value) {
+        public void putLong(String key, long value) {
 
-		}
+        }
 
-		public void remove(String key) {
+        public void remove(String key) {
 
-		}
+        }
 
-		public void removeNode() throws BackingStoreException {
+        public void removeNode() throws BackingStoreException {
 
-		}
+        }
 
-		public void addNodeChangeListener(NodeChangeListener ncl) {
+        public void addNodeChangeListener(NodeChangeListener ncl) {
 
-		}
+        }
 
-		public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
+        public void addPreferenceChangeListener(PreferenceChangeListener pcl) {
 
-		}
+        }
 
-		public void removeNodeChangeListener(NodeChangeListener ncl) {
+        public void removeNodeChangeListener(NodeChangeListener ncl) {
 
-		}
+        }
 
-		public void removePreferenceChangeListener(PreferenceChangeListener pcl) {
+        public void removePreferenceChangeListener(PreferenceChangeListener pcl) {
 
-		}
+        }
 
-		public void sync() throws BackingStoreException {
+        public void sync() throws BackingStoreException {
 
-		}
+        }
 
-		public String toString() {
-			return null;
-		}
+        public String toString() {
+            return null;
+        }
 
-	}
+    }
 
 }