| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package libcore.java.util.prefs; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.ByteArrayOutputStream; |
| import java.io.IOException; |
| import java.util.prefs.AbstractPreferences; |
| import java.util.prefs.BackingStoreException; |
| import java.util.prefs.InvalidPreferencesFormatException; |
| import java.util.prefs.NodeChangeEvent; |
| import java.util.prefs.NodeChangeListener; |
| import java.util.prefs.PreferenceChangeEvent; |
| import java.util.prefs.PreferenceChangeListener; |
| import java.util.prefs.Preferences; |
| import junit.framework.TestCase; |
| |
| public final class OldAbstractPreferencesTest extends TestCase { |
| |
| static final String nodeName = "mock"; |
| |
| AbstractPreferences pref; |
| AbstractPreferences root; |
| AbstractPreferences parent = null; |
| |
| protected void setUp() throws Exception { |
| super.setUp(); |
| |
| root = (AbstractPreferences) Preferences.userRoot(); |
| for (String child : root.childrenNames()) { |
| root.node(child).removeNode(); |
| } |
| root.clear(); |
| |
| parent = (AbstractPreferences) Preferences.userNodeForPackage(getClass()); |
| pref = (AbstractPreferences) parent.node(nodeName); |
| } |
| |
| public void testToString() { |
| assertTrue(pref.toString().contains(nodeName)); |
| } |
| |
| public void testPut() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.flush(); |
| |
| assertEquals("String", pref.get("Value", ":")); |
| |
| try { |
| pref.put(null, "Exception"); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.put(new String(sb), "Exception"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_VALUE_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.put("DoubleValue", new String(sb)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.put("DoubleValue", "Exception"); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGet() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| assertEquals("String", pref.get("Value", ":")); |
| assertEquals("true", pref.get("BoolValue", ":")); |
| assertEquals("9.10938188E-31", pref.get("DoubleValue", null)); |
| |
| try { |
| pref.get(null, "Exception"); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.get("DoubleValue", "Exception"); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testRemove() throws BackingStoreException { |
| String[] keyArray = new String[]{"Value", "DoubleValue", "LongValue", "IntValue"}; |
| pref.put(keyArray[0], "String"); |
| pref.putDouble(keyArray[1], new Double(9.10938188e-31)); |
| pref.putLong(keyArray[2], new Long(Long.MIN_VALUE)); |
| pref.putInt(keyArray[3], 299792458); |
| pref.node("New node"); |
| pref.flush(); |
| |
| String[] str = pref.keys(); |
| assertEquals(keyArray.length, str.length); |
| for(int i = 0; i < keyArray.length; i++) { |
| pref.remove(keyArray[i]); |
| str = pref.keys(); |
| assertEquals(keyArray.length - i - 1, str.length); |
| } |
| assertEquals(1, pref.childrenNames().length); |
| pref.remove("New node"); |
| assertEquals(1, pref.childrenNames().length); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.remove("New node"); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testClear() throws BackingStoreException { |
| AbstractPreferences ap = (AbstractPreferences) pref.node("New node"); |
| pref.putInt("IntValue", 33); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertEquals(33, pref.getInt("IntValue", 22)); |
| assertEquals(1, pref.childrenNames().length); |
| pref.clear(); |
| assertFalse(pref.getBoolean("BoolValue", false)); |
| assertEquals(22, pref.getInt("IntValue", 22)); |
| assertEquals(1, pref.childrenNames().length); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.clear(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| |
| try { |
| ap.clear(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutInt() throws BackingStoreException { |
| pref.putInt("IntValue", 299792458); |
| pref.flush(); |
| |
| assertEquals(299792458, pref.getInt("IntValue", new Integer(1))); |
| |
| try { |
| pref.putInt(null, new Integer(1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putInt(new String(sb), new Integer(1)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putInt("IntValue", new Integer(1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetInt() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putLong("LongValue", new Long(Long.MIN_VALUE)); |
| pref.putInt("IntValue", 299792458); |
| pref.flush(); |
| |
| assertEquals(1, pref.getInt("Value", new Integer(1))); |
| assertEquals(1, pref.getInt("LongValue", new Integer(1))); |
| assertEquals(1, pref.getInt("DoubleValue", new Integer(1))); |
| assertEquals(299792458, pref.getInt("IntValue", new Integer(1))); |
| |
| try { |
| pref.getInt(null, new Integer(1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getInt("IntValue", new Integer(1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutLong() throws BackingStoreException { |
| pref.putLong("LongValue", new Long(299792458)); |
| pref.flush(); |
| |
| assertEquals(299792458L, pref.getLong("LongValue", new Long(1))); |
| |
| try { |
| pref.putLong(null, new Long(1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putLong(new String(sb), new Long(1)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putLong("LongValue", new Long(1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetLong() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putLong("LongValue", new Long(Long.MIN_VALUE)); |
| pref.putInt("IntValue", 299792458); |
| pref.flush(); |
| |
| assertEquals(1L, pref.getLong("Value", new Long(1))); |
| assertEquals(Long.MIN_VALUE, pref.getLong("LongValue", new Long(1))); |
| assertEquals(1L, pref.getLong("DoubleValue", new Long(1))); |
| assertEquals(299792458L, pref.getLong("IntValue", new Long(1))); |
| |
| try { |
| pref.getLong(null, new Long(1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getLong("LongValue", new Long(1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutBoolean() throws BackingStoreException { |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| |
| try { |
| pref.putBoolean(null, true); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putBoolean(new String(sb), true); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putBoolean("DoubleValue", true); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetBoolean() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| assertFalse(pref.getBoolean("Value", false)); |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertFalse(pref.getBoolean("DoubleValue", false)); |
| |
| try { |
| pref.getBoolean(null, true); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getBoolean("DoubleValue", true); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutFloat() throws BackingStoreException { |
| pref.putFloat("FloatValue", new Float(1.602e-19)); |
| pref.flush(); |
| |
| assertEquals(new Float(1.602e-19), pref.getFloat("FloatValue", new Float(0.2))); |
| |
| try { |
| pref.putFloat(null, new Float(0.1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putFloat(new String(sb), new Float(0.1)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putFloat("FloatValue", new Float(0.1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetFloat() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putFloat("FloatValue", new Float(-0.123)); |
| pref.putInt("IntValue", 299792458); |
| pref.flush(); |
| |
| assertEquals(new Float(0.1), pref.getFloat("Value", new Float(0.1))); |
| assertEquals(new Float(-0.123), pref.getFloat("FloatValue", new Float(0.2))); |
| assertEquals(new Float(9.109382e-31), pref.getFloat("DoubleValue", new Float(2.14))); |
| assertEquals(new Float(2.99792448e8), pref.getFloat("IntValue", new Float(5))); |
| |
| try { |
| pref.getFloat(null, new Float(0.1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getFloat("FloatValue", new Float(0.1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutDouble() throws BackingStoreException { |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.flush(); |
| |
| assertEquals(new Double(9.10938188e-31), pref.getDouble("DoubleValue", new Double(2.14))); |
| |
| try { |
| pref.putDouble(null, new Double(0.1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| int i; |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putDouble(new String(sb), new Double(0.1)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putDouble("DoubleValue", new Double(0.1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetDouble() throws BackingStoreException { |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putBoolean("BoolValue", true); |
| pref.putInt("IntValue", 299792458); |
| pref.flush(); |
| |
| assertEquals(new Double(0.1), pref.getDouble("Value", new Double(0.1))); |
| assertEquals(new Double(0.2), pref.getDouble("BoolValue", new Double(0.2))); |
| assertEquals(new Double(9.10938188e-31), pref.getDouble("DoubleValue", new Double(2.14))); |
| assertEquals(new Double(2.99792458e8), pref.getDouble("IntValue", new Double(5))); |
| |
| try { |
| pref.getDouble(null, new Double(0.1)); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getDouble("DoubleValue", new Double(0.1)); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testPutByteArray() throws BackingStoreException { |
| byte[] bArray = new byte[]{1, 2, 3, 4, 5}; |
| byte[] array = null; |
| int i; |
| pref.putByteArray("Array", bArray); |
| pref.flush(); |
| |
| array = pref.getByteArray("Array", null); |
| assertEquals(bArray.length, array.length); |
| for(i = 0; i < bArray.length; i++) { |
| assertEquals(bArray[i], array[i]); |
| } |
| |
| try { |
| pref.putByteArray(null, bArray); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| StringBuffer sb = new StringBuffer(); |
| |
| for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) { |
| sb.append('c'); |
| } |
| |
| try { |
| pref.putByteArray(new String(sb), bArray); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| bArray = new byte[Preferences.MAX_VALUE_LENGTH * 3 / 4 + 1]; |
| |
| try { |
| pref.putByteArray("Big array", bArray); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.putByteArray("Array", new byte[10]); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testGetByteArray() throws BackingStoreException { |
| byte[] bArray = new byte[]{1, 2, 3, 4, 5}; |
| byte[] tmp = new byte[]{5}; |
| byte[] array = null; |
| int i; |
| pref.put("Value", "String"); |
| pref.putDouble("DoubleValue", new Double(9.10938188e-31)); |
| pref.putByteArray("Array", bArray); |
| pref.flush(); |
| |
| array = pref.getByteArray("Value", tmp); |
| assertEquals(tmp.length, array.length); |
| for(i = 0; i < tmp.length; i++) { |
| assertEquals(tmp[i], array[i]); |
| } |
| |
| array = pref.getByteArray("DoubleValue", tmp); |
| assertEquals(tmp.length, array.length); |
| for(i = 0; i < tmp.length; i++) { |
| assertEquals(tmp[i], array[i]); |
| } |
| |
| array = pref.getByteArray("Array", tmp); |
| assertEquals(bArray.length, array.length); |
| for(i = 0; i < bArray.length; i++) { |
| assertEquals(bArray[i], array[i]); |
| } |
| |
| try { |
| pref.getByteArray(null, tmp); |
| fail("NullPointerException expected"); |
| } catch (NullPointerException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.getByteArray("Array", tmp); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testKeys() throws BackingStoreException { |
| String[] keyArray = new String[]{"Value", "DoubleValue", "BoolValue", "IntValue"}; |
| String nodeStr = "New node"; |
| pref.node(nodeStr); |
| pref.put(keyArray[0], "String"); |
| pref.putDouble(keyArray[1], new Double(9.10938188e-31)); |
| pref.putBoolean(keyArray[2], true); |
| pref.putInt(keyArray[3], 299792458); |
| pref.flush(); |
| |
| String[] str = pref.keys(); |
| assertEquals(keyArray.length, str.length); |
| for(int i = 0; i < str.length; i++) { |
| boolean flag = false; |
| for(int j = 0; j < keyArray.length; j++) { |
| if (str[i].compareTo(keyArray[j]) == 0) { |
| flag = true; |
| break; |
| } |
| } |
| assertTrue(str[i].compareTo(nodeStr) != 0); |
| assertTrue(flag); |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.keys(); |
| fail("IllegalStateException expected"); |
| } catch(IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testChildrenNames() throws BackingStoreException { |
| AbstractPreferences first = (AbstractPreferences) pref.node("First node"); |
| AbstractPreferences second = (AbstractPreferences) pref.node("Second node"); |
| |
| assertEquals(2, pref.childrenNames().length); |
| assertEquals(0, first.childrenNames().length); |
| assertEquals(0, second.childrenNames().length); |
| |
| second.removeNode(); |
| |
| try { |
| second.childrenNames(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| first.childrenNames(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void test_nodeExists() throws BackingStoreException { |
| AbstractPreferences test = (AbstractPreferences) Preferences.userRoot() |
| .node("test"); |
| try { |
| test.nodeExists(null); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // Expected |
| } |
| |
| test.removeNode(); |
| try { |
| test.nodeExists(null); |
| fail("should throw NullPointerException"); |
| } catch (NullPointerException e) { |
| // Expected |
| } |
| } |
| |
| public void testParent() throws BackingStoreException { |
| AbstractPreferences node = (AbstractPreferences) pref.node("First node/sub node"); |
| |
| assertTrue(node.parent().name().compareTo("First node") == 0); |
| |
| pref.removeNode(); |
| |
| try { |
| node.parent(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testNode() throws BackingStoreException { |
| AbstractPreferences first = (AbstractPreferences) pref.node("First node"); |
| AbstractPreferences second = (AbstractPreferences) pref.node("Second node"); |
| |
| try { |
| first.node("blabla/"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| try { |
| first.node("///invalid"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| StringBuffer sb = new StringBuffer(); |
| |
| for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) { |
| sb.append('c'); |
| } |
| first.node(new String(sb)); |
| sb.append('c'); |
| |
| try { |
| first.node(new String(sb)); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| second.removeNode(); |
| |
| try { |
| second.node(""); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| pref.removeNode(); |
| try { |
| first.node(""); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testNodeExists() throws BackingStoreException { |
| AbstractPreferences ap1 = (AbstractPreferences) pref.node("First node"); |
| AbstractPreferences ap2 = (AbstractPreferences) pref.node("Second node"); |
| pref.putInt("IntegerValue", 33); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| assertTrue(pref.nodeExists("First node")); |
| assertTrue(pref.nodeExists("Second node")); |
| assertFalse(pref.nodeExists("IntegerValue")); |
| assertFalse(pref.nodeExists("BoolValue")); |
| assertFalse(pref.nodeExists("Value")); |
| assertFalse(pref.nodeExists(nodeName)); |
| |
| try { |
| pref.nodeExists("///invalid"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| pref.removeNode(); |
| |
| try { |
| pref.nodeExists("Exception"); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| public void testRemoveNode() throws BackingStoreException { |
| String[] nodeArray = new String[]{"First node", "Second node", "Last node"}; |
| int i; |
| pref.put("Key", "String"); |
| for (i = 0; i < nodeArray.length; i++) { |
| pref.node(nodeArray[i]); |
| } |
| pref.flush(); |
| |
| String[] str = pref.childrenNames(); |
| assertEquals(nodeArray.length, str.length); |
| for(i = 0; i < nodeArray.length; i++) { |
| pref.node(nodeArray[i]).removeNode(); |
| str = pref.childrenNames(); |
| assertEquals(nodeArray.length - i - 1, str.length); |
| } |
| assertEquals(1, pref.keys().length); |
| pref.node("Key").removeNode(); |
| assertEquals(1, pref.keys().length); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.removeNode(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| |
| try { |
| root.removeNode(); |
| fail("UnsupportedOperationException expected"); |
| } catch (UnsupportedOperationException e) { |
| //expected |
| } |
| } |
| |
| public void testName() { |
| AbstractPreferences first = (AbstractPreferences) pref.node("First node"); |
| AbstractPreferences second = (AbstractPreferences) pref.node("Second node/sub node"); |
| |
| assertTrue(first.name().compareTo("First node") == 0); |
| assertFalse(first.name().compareTo("Second node") == 0); |
| assertTrue(second.name().compareTo("sub node") == 0); |
| } |
| |
| public void testAbsolutePath() { |
| assertEquals(parent.absolutePath() + "/" + nodeName, pref.absolutePath()); |
| assertEquals(parent.absolutePath() + "/" + "new node", parent.node("new node").absolutePath()); |
| } |
| |
| public void testIsUserNode() { |
| assertTrue(parent.isUserNode()); |
| assertFalse(Preferences.systemRoot().isUserNode()); |
| } |
| |
| public void testSync() throws BackingStoreException { |
| pref.node("new node/sub node"); |
| pref.sync(); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.sync(); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| } |
| |
| class MockPreferenceChangeListener implements PreferenceChangeListener { |
| private boolean flagChange = false; |
| |
| public synchronized void preferenceChange(PreferenceChangeEvent arg0) { |
| flagChange = true; |
| notifyAll(); |
| } |
| |
| public synchronized void assertChanged(boolean expected) throws InterruptedException { |
| wait(100); |
| assertEquals(expected, flagChange); |
| flagChange = false; |
| } |
| } |
| |
| public void testAddPreferenceChangeListener() throws Exception { |
| MockPreferenceChangeListener mpcl = new MockPreferenceChangeListener(); |
| parent.addPreferenceChangeListener(mpcl); |
| mpcl.assertChanged(false); |
| pref.node("new node"); |
| mpcl.assertChanged(false); |
| parent.node("new node"); |
| mpcl.assertChanged(false); |
| parent.putInt("IntValue", 33); |
| mpcl.assertChanged(true); |
| assertEquals(33, parent.getInt("IntValue", 22)); |
| mpcl.assertChanged(false); |
| assertEquals(22, parent.getInt("Missed Value", 22)); |
| mpcl.assertChanged(false); |
| } |
| |
| public void testRemovePreferenceChangeListener() throws Exception { |
| MockPreferenceChangeListener mpcl = new MockPreferenceChangeListener(); |
| parent.addPreferenceChangeListener(mpcl); |
| mpcl.assertChanged(false); |
| parent.putInt("IntValue", 33); |
| mpcl.assertChanged(true); |
| parent.removePreferenceChangeListener(mpcl); |
| parent.putInt("IntValue", 33); |
| mpcl.assertChanged(false); |
| } |
| |
| class MockNodeChangeListener implements NodeChangeListener { |
| private boolean flagAdded = false; |
| private boolean flagRemoved = false; |
| |
| public synchronized void childAdded(NodeChangeEvent arg0) { |
| flagAdded = true; |
| notifyAll(); |
| } |
| |
| public synchronized void childRemoved(NodeChangeEvent arg0) { |
| flagRemoved = true; |
| notifyAll(); |
| } |
| |
| public synchronized void assertAdded(boolean expected) throws InterruptedException { |
| wait(100); |
| assertEquals(expected, flagAdded); |
| } |
| |
| public synchronized void assertRemoved(boolean expected) throws InterruptedException { |
| wait(100); |
| assertEquals(expected, flagRemoved); |
| } |
| } |
| |
| public void testAddNodeChangeListener() throws Exception { |
| MockNodeChangeListener mncl = new MockNodeChangeListener(); |
| parent.addNodeChangeListener(mncl); |
| pref.node("test"); |
| mncl.assertAdded(false); |
| mncl.assertRemoved(false); |
| pref.removeNode(); |
| mncl.assertAdded(false); |
| mncl.assertRemoved(true); |
| parent.node("new node"); |
| mncl.assertAdded(true); |
| mncl.assertRemoved(true); |
| } |
| |
| public void testRemoveNodeChangeListener() throws BackingStoreException, InterruptedException { |
| MockNodeChangeListener mncl = new MockNodeChangeListener(); |
| parent.addNodeChangeListener(mncl); |
| pref.node("test"); |
| mncl.assertAdded(false); |
| mncl.assertRemoved(false); |
| parent.removeNodeChangeListener(mncl); |
| pref.removeNode(); |
| mncl.assertAdded(false); |
| mncl.assertRemoved(false); |
| parent.node("new node"); |
| mncl.assertAdded(false); |
| mncl.assertRemoved(false); |
| } |
| |
| public void testExportNode() throws BackingStoreException, IOException, InvalidPreferencesFormatException { |
| AbstractPreferences ap = (AbstractPreferences) pref.node("New node"); |
| pref.putInt("IntValue", 33); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| |
| pref.exportNode(baos); |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertEquals(33, pref.getInt("IntValue", 22)); |
| assertEquals(1, pref.childrenNames().length); |
| |
| String xmlData = new String(baos.toByteArray()); |
| |
| assertTrue(xmlData.contains("IntValue")); |
| assertTrue(xmlData.contains("BoolValue")); |
| assertTrue(xmlData.contains("33")); |
| assertTrue(xmlData.contains("true")); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.exportNode(new ByteArrayOutputStream()); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| |
| try { |
| pref.getBoolean("BoolValue", false); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| pref = (AbstractPreferences) parent.node(nodeName); |
| |
| pref.importPreferences(bais); |
| |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertEquals(33, pref.getInt("IntValue", 22)); |
| assertEquals(0, pref.childrenNames().length); |
| } |
| |
| public void testExportSubtree() throws BackingStoreException, IOException, InvalidPreferencesFormatException { |
| AbstractPreferences ap1 = (AbstractPreferences) pref.node("First node"); |
| AbstractPreferences ap2 = (AbstractPreferences) pref.node("Second node"); |
| pref.putInt("IntegerValue", 33); |
| pref.putBoolean("BoolValue", true); |
| pref.flush(); |
| |
| ap1.putInt("FirstIntValue", 11); |
| ap2.putDouble("DoubleValue", new Double(6.626e-34)); |
| |
| ByteArrayOutputStream baos = new ByteArrayOutputStream(); |
| |
| pref.exportSubtree(baos); |
| ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray()); |
| |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertEquals(33, pref.getInt("IntegerValue", 22)); |
| assertEquals(2, pref.childrenNames().length); |
| assertEquals(11, ap1.getInt("FirstIntValue", 22)); |
| assertEquals(new Double(6.626e-34), ap2.getDouble("DoubleValue", new Double (3.14))); |
| |
| String xmlData = new String(baos.toByteArray()); |
| |
| assertTrue(xmlData.contains("IntegerValue")); |
| assertTrue(xmlData.contains("BoolValue")); |
| assertTrue(xmlData.contains("FirstIntValue")); |
| assertTrue(xmlData.contains("DoubleValue")); |
| assertTrue(xmlData.contains("33")); |
| assertTrue(xmlData.contains("true")); |
| assertTrue(xmlData.contains("11")); |
| assertTrue(xmlData.contains("6.626E-34")); |
| |
| pref.removeNode(); |
| |
| try { |
| pref.exportSubtree(new ByteArrayOutputStream()); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| |
| try { |
| pref.getBoolean("BoolValue", false); |
| fail("IllegalStateException expected"); |
| } catch (IllegalStateException e) { |
| //expected |
| } |
| pref = (AbstractPreferences) parent.node(nodeName); |
| pref.importPreferences(bais); |
| |
| ap1 = (AbstractPreferences) pref.node("First node"); |
| ap2 = (AbstractPreferences) pref.node("Second node"); |
| |
| assertTrue(pref.getBoolean("BoolValue", false)); |
| assertEquals(33, pref.getInt("IntegerValue", 22)); |
| assertEquals(2, pref.childrenNames().length); |
| assertEquals(11, ap1.getInt("FirstIntValue", 22)); |
| assertEquals(new Double(6.626e-34), ap2.getDouble("DoubleValue", new Double (3.14))); |
| } |
| |
| class MockAbstractPreferences extends AbstractPreferences { |
| protected MockAbstractPreferences(AbstractPreferences parent, String name) { |
| super(parent, name); |
| } |
| |
| @Override |
| protected AbstractPreferences childSpi(String name) { |
| return null; |
| } |
| |
| @Override |
| protected String[] childrenNamesSpi() throws BackingStoreException { |
| return null; |
| } |
| |
| @Override |
| protected void flushSpi() throws BackingStoreException { |
| } |
| |
| @Override |
| protected String getSpi(String key) { |
| return null; |
| } |
| |
| @Override |
| protected String[] keysSpi() throws BackingStoreException { |
| return null; |
| } |
| |
| @Override |
| protected void putSpi(String key, String value) { |
| } |
| |
| @Override |
| protected void removeNodeSpi() throws BackingStoreException { |
| } |
| |
| @Override |
| protected void removeSpi(String key) { |
| } |
| |
| @Override |
| protected void syncSpi() throws BackingStoreException { |
| } |
| } |
| |
| public void testAbstractPreferences() { |
| assertNotNull(new MockAbstractPreferences(pref, "node name")); |
| try { |
| new MockAbstractPreferences(pref, "node/name"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| |
| try { |
| new MockAbstractPreferences(null, "node"); |
| fail("IllegalArgumentException expected"); |
| } catch (IllegalArgumentException e) { |
| //expected |
| } |
| } |
| |
| public void testCachedChildren() throws BackingStoreException { |
| pref.node("First node"); |
| pref.node("Second node"); |
| |
| assertEquals(2, pref.childrenNames().length); |
| } |
| } |
