1/* Licensed to the Apache Software Foundation (ASF) under one or more 2 * contributor license agreements. See the NOTICE file distributed with 3 * this work for additional information regarding copyright ownership. 4 * The ASF licenses this file to You under the Apache License, Version 2.0 5 * (the "License"); you may not use this file except in compliance with 6 * the License. You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17package org.apache.harmony.prefs.tests.java.util.prefs; 18 19import java.io.ByteArrayInputStream; 20import java.io.IOException; 21import java.io.InputStream; 22import java.io.OutputStream; 23import java.net.MalformedURLException; 24import java.util.prefs.AbstractPreferences; 25import java.util.prefs.BackingStoreException; 26import java.util.prefs.InvalidPreferencesFormatException; 27import java.util.prefs.NodeChangeListener; 28import java.util.prefs.PreferenceChangeListener; 29import java.util.prefs.Preferences; 30 31import junit.framework.TestCase; 32 33/** 34 * 35 */ 36public class PreferencesTest extends TestCase { 37 38 MockInputStream stream = null; 39 40 InputStream in; 41 42 /* 43 * @see TestCase#setUp() 44 */ 45 @Override 46 protected void setUp() throws Exception { 47 super.setUp(); 48 in = new ByteArrayInputStream("<!DOCTYPE preferences SYSTEM \"http://java.sun.com/dtd/preferences.dtd\"><preferences><root type=\"user\"><map></map></root></preferences>".getBytes("UTF-8")); 49 stream = new MockInputStream(in); 50 } 51 52 /* 53 * @see TestCase#tearDown() 54 */ 55 @Override 56 protected void tearDown() throws Exception { 57 super.tearDown(); 58 stream.close(); 59 } 60 61 public void testSystemNodeForPackage() throws BackingStoreException { 62 Preferences p = null; 63 try { 64 p = Preferences.systemNodeForPackage(Object.class); 65 } catch (SecurityException e) { 66 // may be caused by absence of privileges on the underlying OS 67 return; 68 } 69 assertEquals("/java/lang", p.absolutePath()); 70 assertTrue(p instanceof AbstractPreferences); 71 Preferences root = Preferences.systemRoot(); 72 Preferences parent = root.node("java"); 73 assertSame(parent, p.parent()); 74 assertFalse(p.isUserNode()); 75 assertEquals("lang", p.name()); 76 assertEquals("System Preference Node: " + p.absolutePath(), p 77 .toString()); 78 79 assertEquals(0, p.childrenNames().length); 80 assertEquals(0, p.keys().length); 81 parent.removeNode(); 82 try { 83 Preferences.userNodeForPackage(null); 84 fail("should throw NullPointerException"); 85 } catch (NullPointerException e) { 86 // Expected 87 } 88 } 89 90 public void testSystemRoot() throws BackingStoreException { 91 Preferences p = Preferences.systemRoot(); 92 assertTrue(p instanceof AbstractPreferences); 93 assertEquals("/", p.absolutePath()); 94 assertSame(null, p.parent()); 95 assertFalse(p.isUserNode()); 96 assertEquals("", p.name()); 97 assertEquals("System Preference Node: " + p.absolutePath(), p 98 .toString()); 99 } 100 101 public void testConsts() { 102 assertEquals(80, Preferences.MAX_KEY_LENGTH); 103 assertEquals(80, Preferences.MAX_NAME_LENGTH); 104 assertEquals(8192, Preferences.MAX_VALUE_LENGTH); 105 } 106 107 public void testUserNodeForPackage() throws BackingStoreException { 108 Preferences p = Preferences.userNodeForPackage(Object.class); 109 assertEquals("/java/lang", p.absolutePath()); 110 assertTrue(p instanceof AbstractPreferences); 111 Preferences root = Preferences.userRoot(); 112 Preferences parent = root.node("java"); 113 assertSame(parent, p.parent()); 114 assertTrue(p.isUserNode()); 115 assertEquals("lang", p.name()); 116 assertEquals("User Preference Node: " + p.absolutePath(), p.toString()); 117 assertEquals(0, p.childrenNames().length); 118 assertEquals(0, p.keys().length); 119 120 try { 121 Preferences.userNodeForPackage(null); 122 fail("should throw NullPointerException"); 123 } catch (NullPointerException e) { 124 // Expected 125 } 126 } 127 128 public void testUserRoot() throws BackingStoreException { 129 Preferences p = Preferences.userRoot(); 130 assertTrue(p instanceof AbstractPreferences); 131 assertEquals("/", p.absolutePath()); 132 assertSame(null, p.parent()); 133 assertTrue(p.isUserNode()); 134 assertEquals("", p.name()); 135 assertEquals("User Preference Node: " + p.absolutePath(), p.toString()); 136 } 137 138 public void testImportPreferences() throws Exception { 139 Preferences prefs = null; 140 try { 141 prefs = Preferences.userNodeForPackage(PreferencesTest.class); 142 // assertEquals(0, prefs.childrenNames().length); 143 // assertFalse(prefs.nodeExists("mock/child/grandson")); 144 145 prefs.put("prefskey", "oldvalue"); 146 prefs.put("prefskey2", "oldvalue2"); 147 in = PreferencesTest.class 148 .getResourceAsStream("/prefs/java/util/prefs/userprefs.xml"); 149 Preferences.importPreferences(in); 150 151 prefs = Preferences.userNodeForPackage(PreferencesTest.class); 152 assertEquals(1, prefs.childrenNames().length); 153 assertTrue(prefs.nodeExists("mock/child/grandson")); 154 assertEquals("newvalue", prefs.get("prefskey", null)); 155 assertEquals("oldvalue2", prefs.get("prefskey2", null)); 156 assertEquals("newvalue3", prefs.get("prefskey3", null)); 157 158 in = PreferencesTest.class 159 .getResourceAsStream("/prefs/java/util/prefs/userprefs-badform.xml"); 160 try { 161 Preferences.importPreferences(in); 162 fail("should throw InvalidPreferencesFormatException"); 163 } catch (InvalidPreferencesFormatException e) { 164 // Expected 165 } 166 167 in = PreferencesTest.class 168 .getResourceAsStream("/prefs/java/util/prefs/userprefs-badtype.xml"); 169 try { 170 Preferences.importPreferences(in); 171 fail("should throw InvalidPreferencesFormatException"); 172 } catch (InvalidPreferencesFormatException e) { 173 // Expected 174 } 175 176 in = PreferencesTest.class 177 .getResourceAsStream("/prefs/java/util/prefs/userprefs-badencoding.xml"); 178 try { 179 Preferences.importPreferences(in); 180 fail("should throw InvalidPreferencesFormatException"); 181 } catch (InvalidPreferencesFormatException e) { 182 // Expected 183 } 184 185 in = PreferencesTest.class 186 .getResourceAsStream("/prefs/java/util/prefs/userprefs-higherversion.xml"); 187 try { 188 Preferences.importPreferences(in); 189 fail("should throw InvalidPreferencesFormatException"); 190 } catch (InvalidPreferencesFormatException e) { 191 // Expected 192 } 193 194 in = PreferencesTest.class 195 .getResourceAsStream("/prefs/java/util/prefs/userprefs-ascii.xml"); 196 Preferences.importPreferences(in); 197 prefs = Preferences.userNodeForPackage(PreferencesTest.class); 198 } finally { 199 try { 200 prefs = Preferences.userNodeForPackage(PreferencesTest.class); 201 prefs.removeNode(); 202 } catch (Exception e) { 203 // Ignored 204 } 205 } 206 } 207 208 public void testImportPreferencesException() throws Exception { 209 try { 210 Preferences.importPreferences(null); 211 fail("should throw MalformedURLException"); 212 } catch (MalformedURLException e) { 213 // Expected 214 } 215 216 byte[] source = new byte[0]; 217 InputStream in = new ByteArrayInputStream(source); 218 try { 219 Preferences.importPreferences(in); 220 fail("should throw InvalidPreferencesFormatException"); 221 } catch (InvalidPreferencesFormatException e) { 222 // Expected 223 } 224 225 stream.setResult(MockInputStream.exception); 226 try { 227 Preferences.importPreferences(stream); 228 fail("should throw IOException"); 229 } catch (IOException e) { 230 // Expected 231 } 232 233 stream.setResult(MockInputStream.runtimeException); 234 try { 235 Preferences.importPreferences(stream); 236 fail("should throw RuntimeException"); 237 } catch (RuntimeException e) { 238 // Expected 239 } 240 } 241 242 static class MockInputStream extends InputStream { 243 244 static final int normal = 0; 245 246 static final int exception = 1; 247 248 static final int runtimeException = 2; 249 250 int result = normal; 251 252 InputStream wrapper; 253 254 public void setResult(int i) { 255 result = i; 256 } 257 258 private void checkException() throws IOException { 259 switch (result) { 260 case normal: 261 return; 262 case exception: 263 throw new IOException("test"); 264 case runtimeException: 265 throw new RuntimeException("test"); 266 } 267 } 268 269 public MockInputStream(InputStream in) { 270 wrapper = in; 271 } 272 273 @Override 274 public int read() throws IOException { 275 checkException(); 276 return wrapper.read(); 277 } 278 } 279 280 static class MockPreferences extends Preferences { 281 282 public MockPreferences() { 283 super(); 284 } 285 286 @Override 287 public String absolutePath() { 288 return null; 289 } 290 291 @Override 292 public String[] childrenNames() throws BackingStoreException { 293 return null; 294 } 295 296 @Override 297 public void clear() throws BackingStoreException { 298 } 299 300 @Override 301 public void exportNode(OutputStream ostream) throws IOException, 302 BackingStoreException { 303 } 304 305 @Override 306 public void exportSubtree(OutputStream ostream) throws IOException, 307 BackingStoreException { 308 } 309 310 @Override 311 public void flush() throws BackingStoreException { 312 } 313 314 @Override 315 public String get(String key, String deflt) { 316 return null; 317 } 318 319 @Override 320 public boolean getBoolean(String key, boolean deflt) { 321 return false; 322 } 323 324 @Override 325 public byte[] getByteArray(String key, byte[] deflt) { 326 return null; 327 } 328 329 @Override 330 public double getDouble(String key, double deflt) { 331 return 0; 332 } 333 334 @Override 335 public float getFloat(String key, float deflt) { 336 return 0; 337 } 338 339 @Override 340 public int getInt(String key, int deflt) { 341 return 0; 342 } 343 344 @Override 345 public long getLong(String key, long deflt) { 346 return 0; 347 } 348 349 @Override 350 public boolean isUserNode() { 351 return false; 352 } 353 354 @Override 355 public String[] keys() throws BackingStoreException { 356 return null; 357 } 358 359 @Override 360 public String name() { 361 return null; 362 } 363 364 @Override 365 public Preferences node(String name) { 366 return null; 367 } 368 369 @Override 370 public boolean nodeExists(String name) throws BackingStoreException { 371 return false; 372 } 373 374 @Override 375 public Preferences parent() { 376 return null; 377 } 378 379 @Override 380 public void put(String key, String value) { 381 382 } 383 384 @Override 385 public void putBoolean(String key, boolean value) { 386 387 } 388 389 @Override 390 public void putByteArray(String key, byte[] value) { 391 392 } 393 394 @Override 395 public void putDouble(String key, double value) { 396 397 } 398 399 @Override 400 public void putFloat(String key, float value) { 401 402 } 403 404 @Override 405 public void putInt(String key, int value) { 406 407 } 408 409 @Override 410 public void putLong(String key, long value) { 411 412 } 413 414 @Override 415 public void remove(String key) { 416 417 } 418 419 @Override 420 public void removeNode() throws BackingStoreException { 421 422 } 423 424 @Override 425 public void addNodeChangeListener(NodeChangeListener ncl) { 426 427 } 428 429 @Override 430 public void addPreferenceChangeListener(PreferenceChangeListener pcl) { 431 432 } 433 434 @Override 435 public void removeNodeChangeListener(NodeChangeListener ncl) { 436 437 } 438 439 @Override 440 public void removePreferenceChangeListener(PreferenceChangeListener pcl) { 441 442 } 443 444 @Override 445 public void sync() throws BackingStoreException { 446 447 } 448 449 @Override 450 public String toString() { 451 return null; 452 } 453 454 } 455 456} 457