| /* Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.harmony.prefs.tests.java.util.prefs; |
| |
| import dalvik.annotation.TestLevel; |
| import dalvik.annotation.TestTargetClass; |
| import dalvik.annotation.TestTargetNew; |
| import dalvik.annotation.TestTargets; |
| import junit.framework.TestCase; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.net.MalformedURLException; |
| import java.util.Arrays; |
| import java.util.prefs.AbstractPreferences; |
| import java.util.prefs.BackingStoreException; |
| import java.util.prefs.InvalidPreferencesFormatException; |
| import java.util.prefs.NodeChangeListener; |
| import java.util.prefs.PreferenceChangeListener; |
| import java.util.prefs.Preferences; |
| |
| /** |
| * |
| */ |
| @TestTargetClass(Preferences.class) |
| public class PreferencesTest extends TestCase { |
| |
| 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() |
| */ |
| @Override |
| 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() |
| */ |
| @Override |
| protected void tearDown() throws Exception { |
| stream.close(); |
| super.tearDown(); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "systemNodeForPackage", |
| args = {java.lang.Class.class} |
| ) |
| public void testSystemNodeForPackage() { |
| 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.systemNodeForPackage(null); |
| fail("NullPointerException has not been thrown"); |
| } catch (NullPointerException e) { |
| // expected |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "SecurityException checking missed.", |
| method = "systemRoot", |
| args = {} |
| ) |
| public void testSystemRoot() { |
| 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); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Checks constant values", |
| method = "!Constants", |
| args = {} |
| ) |
| public void testConsts() { |
| assertEquals(80, Preferences.MAX_KEY_LENGTH); |
| assertEquals(80, Preferences.MAX_NAME_LENGTH); |
| assertEquals(8192, Preferences.MAX_VALUE_LENGTH); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "SecurityException checking missed.", |
| method = "userNodeForPackage", |
| args = {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) { |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "SecurityException checking missed.", |
| method = "userRoot", |
| args = {} |
| ) |
| public void testUserRoot() { |
| 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); |
| } |
| |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "SecurityException & IOException checking missed.", |
| method = "importPreferences", |
| args = {java.io.InputStream.class} |
| ) |
| public void testImportPreferences2() throws Exception { |
| InputStream 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) { |
| } catch (UnsupportedEncodingException e) { |
| } |
| |
| } |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "SecurityException & IOException checking missed.", |
| method = "importPreferences", |
| args = {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-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) { |
| } |
| } |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.PARTIAL_COMPLETE, |
| notes = "Test for Exceptions only.", |
| method = "importPreferences", |
| args = {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) { |
| } |
| } |
| |
| @TestTargets({ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "absolutePath", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "childrenNames", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "clear", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "exportNode", |
| args = {java.io.OutputStream.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "exportSubtree", |
| args = {java.io.OutputStream.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "flush", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "get", |
| args = {java.lang.String.class, java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getBoolean", |
| args = {java.lang.String.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getByteArray", |
| args = {java.lang.String.class, byte[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getFloat", |
| args = {java.lang.String.class, float.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getDouble", |
| args = {java.lang.String.class, double.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getInt", |
| args = {java.lang.String.class, int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "getLong", |
| args = {java.lang.String.class, long.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "isUserNode", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "keys", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "name", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "node", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "nodeExists", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "parent", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "put", |
| args = {java.lang.String.class, java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putBoolean", |
| args = {java.lang.String.class, boolean.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putByteArray", |
| args = {java.lang.String.class, byte[].class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putDouble", |
| args = {java.lang.String.class, double.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putFloat", |
| args = {java.lang.String.class, float.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putInt", |
| args = {java.lang.String.class, int.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "putLong", |
| args = {java.lang.String.class, long.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "remove", |
| args = {java.lang.String.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "removeNode", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "addNodeChangeListener", |
| args = {java.util.prefs.NodeChangeListener.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "addPreferenceChangeListener", |
| args = {java.util.prefs.PreferenceChangeListener.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "removeNodeChangeListener", |
| args = {java.util.prefs.NodeChangeListener.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "removePreferenceChangeListener", |
| args = {java.util.prefs.PreferenceChangeListener.class} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "sync", |
| args = {} |
| ), |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Test for abstract methods.", |
| method = "toString", |
| args = {} |
| ) |
| }) |
| 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(); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "Preferences", |
| args = {} |
| ) |
| public void testConstructor() { |
| MockPreferences mp = new MockPreferences(); |
| assertEquals(mp.getClass(), MockPreferences.class); |
| } |
| |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "Check existed implementation", |
| method = "toString", |
| args = {} |
| ) |
| 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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "absolutePath", |
| args = {} |
| ) |
| public void testAbsolutePath() { |
| Preferences p = Preferences.userNodeForPackage(Preferences.class); |
| assertEquals("/java/util/prefs", p.absolutePath()); |
| |
| } |
| |
| /** |
| * @test java.util.prefs.Preferences#childrenNames() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "childrenNames", |
| args = {} |
| ) |
| 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(3, pref.childrenNames().length); |
| assertEquals("child1", pref.childrenNames()[0]); |
| assertEquals(1, child1.childrenNames().length); |
| assertEquals("subchild1", child1.childrenNames()[0]); |
| } |
| |
| /** |
| * @test java.util.prefs.Preferences#clear() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "clear", |
| args = {} |
| ) |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "get", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getBoolean", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getByteArray", |
| args = {java.lang.String.class, byte[].class} |
| ) |
| public void testGetByteArray() { |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getDouble", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getFloat", |
| args = {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); |
| assertEquals(0f, pref.getFloat("testGetFloatKey2", 0f), 0); |
| } |
| |
| /** |
| * @test java.util.prefs.Preferences#getInt(String key, int def) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getInt", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "getLong", |
| args = {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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "isUserNode", |
| args = {} |
| ) |
| 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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Exceptions checking missed, but method is abstract, probably it is OK", |
| method = "keys", |
| args = {} |
| ) |
| 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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "name", |
| args = {} |
| ) |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "node", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException & BackingStoreException checking missed, but method is abstract, probably it is OK", |
| method = "nodeExists", |
| args = {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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "parent", |
| args = {} |
| ) |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "put", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putBoolean", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putDouble", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putFloat", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putInt", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putLong", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "putByteArray", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.COMPLETE, |
| notes = "", |
| method = "remove", |
| args = {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() |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Exceptions checking missed, but method is abstract, probably it is OK", |
| method = "removeNode", |
| args = {} |
| ) |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Only NullPointerException checked, but method is abstract, probably it is OK", |
| method = "addNodeChangeListener", |
| args = {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"); |
| nl.waitForEvent(); |
| assertEquals(1, nl.getAdded()); |
| nl.reset(); |
| child2 = pref.node("mock1"); |
| nl.waitForEvent(); |
| 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"); |
| nl.waitForEvent(); |
| 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(); |
| nl.waitForEvent(); |
| 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(); |
| nl.waitForEvent(); |
| 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"); |
| nl.waitForEvent(); |
| assertEquals(1, nl.getAdded()); |
| nl.reset(); |
| child3 = pref.node("mock4/mock5/mock6"); |
| nl.waitForEvent(); |
| assertEquals(0, nl.getAdded()); |
| nl.reset(); |
| |
| child3.removeNode(); |
| nl.waitForEvent(); |
| assertEquals(0, nl.getRemoved()); |
| nl.reset(); |
| |
| child3 = pref.node("mock4/mock7"); |
| nl.waitForEvent(); |
| assertEquals(1, nl.getAdded()); |
| nl.reset(); |
| |
| child1.removeNode(); |
| nl.waitForEvent(); |
| assertEquals(2, nl.getRemoved()); // fail 1 |
| nl.reset(); |
| } finally { |
| try { |
| child1.removeNode(); |
| } catch (Exception e) { |
| } |
| } |
| |
| } |
| |
| /** |
| * @test java.util.prefs.Preferences#addPreferenceChangeListener(PreferenceChangeListener pcl) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "Only NullPointerException checked, but method is abstract, probably it is OK", |
| method = "addPreferenceChangeListener", |
| args = {java.util.prefs.PreferenceChangeListener.class} |
| ) |
| public void testAddPreferenceChangeListener() { |
| |
| Preferences pref = Preferences.userNodeForPackage(Preferences.class); |
| MockPreferenceChangeListener pl = null; |
| |
| 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); |
| pl.waitForEvent(); |
| assertEquals(1, pl.getChanged()); |
| pref.putLong("long_key", Long.MAX_VALUE); |
| pl.waitForEvent(2); |
| assertEquals(2, pl.getChanged()); |
| pl.reset(); |
| try { |
| pref.clear(); |
| pl.waitForEvent(2); |
| assertEquals(2, pl.getChanged()); // fail 1 |
| } 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); |
| pl.waitForEvent(2); |
| 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); |
| pl.waitForEvent(); |
| assertEquals(1, pl.getChanged()); |
| try { |
| pref.clear(); |
| pl.waitForEvent(3); |
| assertEquals(3, pl.getChanged()); // fails |
| } 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(); |
| pl.waitForEvent(4); |
| 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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "removeNodeChangeListener", |
| args = {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) |
| * |
| */ |
| @TestTargetNew( |
| level = TestLevel.PARTIAL, |
| notes = "IllegalStateException checking missed, but method is abstract, probably it is OK", |
| method = "removePreferenceChangeListener", |
| args = {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; |
| } |
| |
| @Override |
| public int read() throws IOException { |
| checkException(); |
| return wrapper.read(); |
| } |
| } |
| |
| @SuppressWarnings("unused") |
| static class MockPreferences extends Preferences { |
| |
| public MockPreferences() { |
| super(); |
| } |
| |
| @Override |
| public String absolutePath() { |
| return null; |
| } |
| |
| @Override |
| public String[] childrenNames() throws BackingStoreException { |
| return null; |
| } |
| |
| @Override |
| public void clear() throws BackingStoreException { |
| } |
| |
| @Override |
| public void exportNode(OutputStream ostream) throws IOException, |
| BackingStoreException { |
| } |
| |
| @Override |
| public void exportSubtree(OutputStream ostream) throws IOException, |
| BackingStoreException { |
| } |
| |
| @Override |
| public void flush() throws BackingStoreException { |
| } |
| |
| @Override |
| public String get(String key, String deflt) { |
| return null; |
| } |
| |
| @Override |
| public boolean getBoolean(String key, boolean deflt) { |
| return false; |
| } |
| |
| @Override |
| public byte[] getByteArray(String key, byte[] deflt) { |
| return null; |
| } |
| |
| @Override |
| public double getDouble(String key, double deflt) { |
| return 0; |
| } |
| |
| @Override |
| public float getFloat(String key, float deflt) { |
| return 0; |
| } |
| |
| @Override |
| public int getInt(String key, int deflt) { |
| return 0; |
| } |
| |
| @Override |
| public long getLong(String key, long deflt) { |
| return 0; |
| } |
| |
| @Override |
| public boolean isUserNode() { |
| return false; |
| } |
| |
| @Override |
| public String[] keys() throws BackingStoreException { |
| return null; |
| } |
| |
| @Override |
| public String name() { |
| return null; |
| } |
| |
| @Override |
| public Preferences node(String name) { |
| return null; |
| } |
| |
| @Override |
| public boolean nodeExists(String name) throws BackingStoreException { |
| return false; |
| } |
| |
| @Override |
| public Preferences parent() { |
| return null; |
| } |
| |
| @Override |
| public void put(String key, String value) { |
| |
| } |
| |
| @Override |
| public void putBoolean(String key, boolean value) { |
| |
| } |
| |
| @Override |
| public void putByteArray(String key, byte[] value) { |
| |
| } |
| |
| @Override |
| public void putDouble(String key, double value) { |
| |
| } |
| |
| @Override |
| public void putFloat(String key, float value) { |
| |
| } |
| |
| @Override |
| public void putInt(String key, int value) { |
| |
| } |
| |
| @Override |
| public void putLong(String key, long value) { |
| |
| } |
| |
| @Override |
| public void remove(String key) { |
| |
| } |
| |
| @Override |
| public void removeNode() throws BackingStoreException { |
| |
| } |
| |
| @Override |
| public void addNodeChangeListener(NodeChangeListener ncl) { |
| |
| } |
| |
| @Override |
| public void addPreferenceChangeListener(PreferenceChangeListener pcl) { |
| |
| } |
| |
| @Override |
| public void removeNodeChangeListener(NodeChangeListener ncl) { |
| |
| } |
| |
| @Override |
| public void removePreferenceChangeListener(PreferenceChangeListener pcl) { |
| |
| } |
| |
| @Override |
| public void sync() throws BackingStoreException { |
| |
| } |
| |
| @Override |
| public String toString() { |
| return null; |
| } |
| |
| } |
| |
| } |
