libcore/luni/src/test/java/org/apache/harmony/prefs/tests/java/util/prefs/AbstractPreferencesTest.java

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * 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
  17 package org.apache.harmony.prefs.tests.java.util.prefs;
  18
  19 import dalvik.annotation.TestLevel;
  20 import dalvik.annotation.TestTargetClass;
  21 import dalvik.annotation.TestTargetNew;
  22 import dalvik.annotation.TestTargets;
  23 import junit.framework.TestCase;
  24
  25 import java.io.ByteArrayInputStream;
  26 import java.io.ByteArrayOutputStream;
  27 import java.io.IOException;
  28 import java.util.prefs.AbstractPreferences;
  29 import java.util.prefs.BackingStoreException;
  30 import java.util.prefs.InvalidPreferencesFormatException;
  31 import java.util.prefs.NodeChangeEvent;
  32 import java.util.prefs.NodeChangeListener;
  33 import java.util.prefs.PreferenceChangeEvent;
  34 import java.util.prefs.PreferenceChangeListener;
  35 import java.util.prefs.Preferences;
  36
  37 @TestTargetClass(AbstractPreferences.class)
  38 public class AbstractPreferencesTest extends TestCase {
  39
  40     AbstractPreferences pref;
  41
  42     static AbstractPreferences root;
  43
  44     static final String nodeName = "mock";
  45
  46     static AbstractPreferences parent = null;
  47
  48     String oldUserHome = System.getProperty("user.home");
  49     String oldJavaHome = System.getProperty("java.home");
  50
  51     protected void setUp() throws Exception {
  52         super.setUp();
  53
  54         root = (AbstractPreferences) Preferences.userRoot();
  55         parent = (AbstractPreferences) Preferences.userNodeForPackage(this.getClass());
  56
  57         pref = (AbstractPreferences) parent.node(nodeName);
  58     }
  59
  60     protected void tearDown() throws Exception {
  61         super.tearDown();
  62     }
  63
  64     @TestTargetNew(
  65         level = TestLevel.COMPLETE,
  66         notes = "",
  67         method = "toString",
  68         args = {}
  69     )
  70     public void testToString() {
  71         assertTrue(pref.toString().contains(nodeName));
  72     }
  73
  74     @TestTargets({
  75         @TestTargetNew(
  76             level = TestLevel.COMPLETE,
  77             notes = "Tests putSpi indirectly",
  78             method = "put",
  79             args = {java.lang.String.class, java.lang.String.class}
  80         ),
  81         @TestTargetNew(
  82             level = TestLevel.COMPLETE,
  83             notes = "Tests putSpi indirectly",
  84             method = "putSpi",
  85             args = {java.lang.String.class, java.lang.String.class}
  86         )
  87     })
  88     public void testPut() throws BackingStoreException {
  89         pref.put("Value", "String");
  90         pref.flush();
  91
  92         assertEquals("String", pref.get("Value", ":"));
  93
  94         try {
  95             pref.put(null, "Exception");
  96             fail("NullPointerException expected");
  97         } catch (NullPointerException e) {
  98             //expected
  99         }
 100
 101         int i;
 102         StringBuffer sb = new StringBuffer();
 103
 104         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 105             sb.append('c');
 106         }
 107
 108         try {
 109             pref.put(new String(sb), "Exception");
 110             fail("IllegalArgumentException expected");
 111         } catch (IllegalArgumentException e) {
 112             //expected
 113         }
 114
 115         sb = new StringBuffer();
 116
 117         for (i = 0; i < Preferences.MAX_VALUE_LENGTH + 1; i++) {
 118             sb.append('c');
 119         }
 120
 121         try {
 122             pref.put("DoubleValue", new String(sb));
 123             fail("IllegalArgumentException expected");
 124         } catch (IllegalArgumentException e) {
 125             //expected
 126         }
 127
 128         pref.removeNode();
 129
 130         try {
 131             pref.put("DoubleValue", "Exception");
 132             fail("IllegalStateException expected");
 133         } catch (IllegalStateException e) {
 134             //expected
 135         }
 136     }
 137
 138     @TestTargets({
 139         @TestTargetNew(
 140             level = TestLevel.COMPLETE,
 141             notes = "getSpi tested indirectly.",
 142             method = "get",
 143             args = {java.lang.String.class, java.lang.String.class}
 144         ),
 145         @TestTargetNew(
 146             level = TestLevel.COMPLETE,
 147             notes = "getSpi tested indirectly.",
 148             method = "getSpi",
 149             args = {java.lang.String.class}
 150         )
 151     })
 152     public void testGet() throws BackingStoreException {
 153         pref.put("Value", "String");
 154         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 155         pref.putBoolean("BoolValue", true);
 156         pref.flush();
 157
 158         assertEquals("String", pref.get("Value", ":"));
 159         assertEquals("true", pref.get("BoolValue", ":"));
 160         assertEquals("9.10938188E-31", pref.get("DoubleValue", null));
 161
 162         try {
 163             pref.get(null, "Exception");
 164             fail("NullPointerException expected");
 165         } catch (NullPointerException e) {
 166             //expected
 167         }
 168
 169         pref.removeNode();
 170
 171         try {
 172             pref.get("DoubleValue", "Exception");
 173             fail("IllegalStateException expected");
 174         } catch (IllegalStateException e) {
 175             //expected
 176         }
 177     }
 178
 179     @TestTargets({
 180         @TestTargetNew(
 181             level = TestLevel.COMPLETE,
 182             notes = "Indirectly checks removeSpi",
 183             method = "remove",
 184             args = {java.lang.String.class}
 185         ),
 186         @TestTargetNew(
 187             level = TestLevel.COMPLETE,
 188             notes = "Indirectly checks removeSpi",
 189             method = "removeSpi",
 190             args = {java.lang.String.class}
 191         )
 192     })
 193     public void testRemove() throws BackingStoreException {
 194         String[] keyArray = new String[]{"Value", "DoubleValue", "LongValue", "IntValue"};
 195         pref.put(keyArray[0], "String");
 196         pref.putDouble(keyArray[1], new Double(9.10938188e-31));
 197         pref.putLong(keyArray[2], new Long(Long.MIN_VALUE));
 198         pref.putInt(keyArray[3], 299792458);
 199         pref.node("New node");
 200         pref.flush();
 201
 202         String[] str = pref.keys();
 203         assertEquals(keyArray.length, str.length);
 204         for(int i = 0; i < keyArray.length; i++) {
 205             pref.remove(keyArray[i]);
 206             str = pref.keys();
 207             assertEquals(keyArray.length - i - 1, str.length);
 208         }
 209         assertEquals(1, pref.childrenNames().length);
 210         pref.remove("New node");
 211         assertEquals(1, pref.childrenNames().length);
 212
 213         pref.removeNode();
 214
 215         try {
 216             pref.remove("New node");
 217             fail("IllegalStateException expected");
 218         } catch (IllegalStateException e) {
 219             //expected
 220         }
 221     }
 222
 223     @TestTargetNew(
 224         level = TestLevel.COMPLETE,
 225         notes = "",
 226         method = "clear",
 227         args = {}
 228     )
 229     public void testClear() throws BackingStoreException {
 230         AbstractPreferences ap = (AbstractPreferences) pref.node("New node");
 231         pref.putInt("IntValue", 33);
 232         pref.putBoolean("BoolValue", true);
 233         pref.flush();
 234         assertTrue(pref.getBoolean("BoolValue", false));
 235         assertEquals(33, pref.getInt("IntValue", 22));
 236         assertEquals(1, pref.childrenNames().length);
 237         pref.clear();
 238         assertFalse(pref.getBoolean("BoolValue", false));
 239         assertEquals(22, pref.getInt("IntValue", 22));
 240         assertEquals(1, pref.childrenNames().length);
 241
 242         pref.removeNode();
 243
 244         try {
 245             pref.clear();
 246             fail("IllegalStateException expected");
 247         } catch (IllegalStateException e) {
 248             //expected
 249         }
 250
 251         try {
 252             ap.clear();
 253             fail("IllegalStateException expected");
 254         } catch (IllegalStateException e) {
 255             //expected
 256         }
 257     }
 258
 259     @TestTargetNew(
 260         level = TestLevel.COMPLETE,
 261         notes = "",
 262         method = "putInt",
 263         args = {java.lang.String.class, int.class}
 264     )
 265     public void testPutInt() throws BackingStoreException {
 266         pref.putInt("IntValue", 299792458);
 267         pref.flush();
 268
 269         assertEquals(299792458, pref.getInt("IntValue", new Integer(1)));
 270
 271         try {
 272             pref.putInt(null, new Integer(1));
 273             fail("NullPointerException expected");
 274         } catch (NullPointerException e) {
 275             //expected
 276         }
 277
 278         int i;
 279         StringBuffer sb = new StringBuffer();
 280
 281         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 282             sb.append('c');
 283         }
 284
 285         try {
 286             pref.putInt(new String(sb), new Integer(1));
 287             fail("IllegalArgumentException expected");
 288         } catch (IllegalArgumentException e) {
 289             //expected
 290         }
 291
 292         pref.removeNode();
 293
 294         try {
 295             pref.putInt("IntValue", new Integer(1));
 296             fail("IllegalStateException expected");
 297         } catch (IllegalStateException e) {
 298             //expected
 299         }
 300     }
 301
 302     @TestTargetNew(
 303         level = TestLevel.COMPLETE,
 304         notes = "",
 305         method = "getInt",
 306         args = {java.lang.String.class, int.class}
 307     )
 308     public void testGetInt() throws BackingStoreException {
 309         pref.put("Value", "String");
 310         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 311         pref.putLong("LongValue", new Long(Long.MIN_VALUE));
 312         pref.putInt("IntValue", 299792458);
 313         pref.flush();
 314
 315         assertEquals(1, pref.getInt("Value", new Integer(1)));
 316         assertEquals(1, pref.getInt("LongValue", new Integer(1)));
 317         assertEquals(1, pref.getInt("DoubleValue", new Integer(1)));
 318         assertEquals(299792458, pref.getInt("IntValue", new Integer(1)));
 319
 320         try {
 321             pref.getInt(null, new Integer(1));
 322             fail("NullPointerException expected");
 323         } catch (NullPointerException e) {
 324             //expected
 325         }
 326
 327         pref.removeNode();
 328
 329         try {
 330             pref.getInt("IntValue", new Integer(1));
 331             fail("IllegalStateException expected");
 332         } catch (IllegalStateException e) {
 333             //expected
 334         }
 335     }
 336
 337     @TestTargetNew(
 338         level = TestLevel.COMPLETE,
 339         notes = "",
 340         method = "putLong",
 341         args = {java.lang.String.class, long.class}
 342     )
 343     public void testPutLong() throws BackingStoreException {
 344         pref.putLong("LongValue", new Long(299792458));
 345         pref.flush();
 346
 347         assertEquals(299792458L, pref.getLong("LongValue", new Long(1)));
 348
 349         try {
 350             pref.putLong(null, new Long(1));
 351             fail("NullPointerException expected");
 352         } catch (NullPointerException e) {
 353             //expected
 354         }
 355
 356         int i;
 357         StringBuffer sb = new StringBuffer();
 358
 359         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 360             sb.append('c');
 361         }
 362
 363         try {
 364             pref.putLong(new String(sb), new Long(1));
 365             fail("IllegalArgumentException expected");
 366         } catch (IllegalArgumentException e) {
 367             //expected
 368         }
 369
 370         pref.removeNode();
 371
 372         try {
 373             pref.putLong("LongValue", new Long(1));
 374             fail("IllegalStateException expected");
 375         } catch (IllegalStateException e) {
 376             //expected
 377         }
 378     }
 379
 380     @TestTargetNew(
 381         level = TestLevel.COMPLETE,
 382         notes = "",
 383         method = "getLong",
 384         args = {java.lang.String.class, long.class}
 385     )
 386     public void testGetLong() throws BackingStoreException {
 387         pref.put("Value", "String");
 388         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 389         pref.putLong("LongValue", new Long(Long.MIN_VALUE));
 390         pref.putInt("IntValue", 299792458);
 391         pref.flush();
 392
 393         assertEquals(1L, pref.getLong("Value", new Long(1)));
 394         assertEquals(Long.MIN_VALUE, pref.getLong("LongValue", new Long(1)));
 395         assertEquals(1L, pref.getLong("DoubleValue", new Long(1)));
 396         assertEquals(299792458L, pref.getLong("IntValue", new Long(1)));
 397
 398         try {
 399             pref.getLong(null, new Long(1));
 400             fail("NullPointerException expected");
 401         } catch (NullPointerException e) {
 402             //expected
 403         }
 404
 405         pref.removeNode();
 406
 407         try {
 408             pref.getLong("LongValue", new Long(1));
 409             fail("IllegalStateException expected");
 410         } catch (IllegalStateException e) {
 411             //expected
 412         }
 413     }
 414
 415     @TestTargetNew(
 416         level = TestLevel.COMPLETE,
 417         notes = "",
 418         method = "putBoolean",
 419         args = {java.lang.String.class, boolean.class}
 420     )
 421     public void testPutBoolean() throws BackingStoreException {
 422         pref.putBoolean("BoolValue", true);
 423         pref.flush();
 424
 425         assertTrue(pref.getBoolean("BoolValue", false));
 426
 427         try {
 428             pref.putBoolean(null, true);
 429             fail("NullPointerException expected");
 430         } catch (NullPointerException e) {
 431             //expected
 432         }
 433
 434         int i;
 435         StringBuffer sb = new StringBuffer();
 436
 437         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 438             sb.append('c');
 439         }
 440
 441         try {
 442             pref.putBoolean(new String(sb), true);
 443             fail("IllegalArgumentException expected");
 444         } catch (IllegalArgumentException e) {
 445             //expected
 446         }
 447
 448         pref.removeNode();
 449
 450         try {
 451             pref.putBoolean("DoubleValue", true);
 452             fail("IllegalStateException expected");
 453         } catch (IllegalStateException e) {
 454             //expected
 455         }
 456     }
 457
 458     @TestTargetNew(
 459         level = TestLevel.COMPLETE,
 460         notes = "",
 461         method = "getBoolean",
 462         args = {java.lang.String.class, boolean.class}
 463     )
 464     public void testGetBoolean() throws BackingStoreException {
 465         pref.put("Value", "String");
 466         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 467         pref.putBoolean("BoolValue", true);
 468         pref.flush();
 469
 470         assertFalse(pref.getBoolean("Value", false));
 471         assertTrue(pref.getBoolean("BoolValue", false));
 472         assertFalse(pref.getBoolean("DoubleValue", false));
 473
 474         try {
 475             pref.getBoolean(null, true);
 476             fail("NullPointerException expected");
 477         } catch (NullPointerException e) {
 478             //expected
 479         }
 480
 481         pref.removeNode();
 482
 483         try {
 484             pref.getBoolean("DoubleValue", true);
 485             fail("IllegalStateException expected");
 486         } catch (IllegalStateException e) {
 487             //expected
 488         }
 489     }
 490
 491     @TestTargetNew(
 492         level = TestLevel.COMPLETE,
 493         notes = "",
 494         method = "putFloat",
 495         args = {java.lang.String.class, float.class}
 496     )
 497     public void testPutFloat() throws BackingStoreException {
 498         pref.putFloat("FloatValue", new Float(1.602e-19));
 499         pref.flush();
 500
 501         assertEquals(new Float(1.602e-19), pref.getFloat("FloatValue", new Float(0.2)));
 502
 503         try {
 504             pref.putFloat(null, new Float(0.1));
 505             fail("NullPointerException expected");
 506         } catch (NullPointerException e) {
 507             //expected
 508         }
 509
 510         int i;
 511         StringBuffer sb = new StringBuffer();
 512
 513         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 514             sb.append('c');
 515         }
 516
 517         try {
 518             pref.putFloat(new String(sb), new Float(0.1));
 519             fail("IllegalArgumentException expected");
 520         } catch (IllegalArgumentException e) {
 521             //expected
 522         }
 523
 524         pref.removeNode();
 525
 526         try {
 527             pref.putFloat("FloatValue", new Float(0.1));
 528             fail("IllegalStateException expected");
 529         } catch (IllegalStateException e) {
 530             //expected
 531         }
 532     }
 533
 534     @TestTargetNew(
 535         level = TestLevel.COMPLETE,
 536         notes = "",
 537         method = "getFloat",
 538         args = {java.lang.String.class, float.class}
 539     )
 540     public void testGetFloat() throws BackingStoreException {
 541         pref.put("Value", "String");
 542         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 543         pref.putFloat("FloatValue", new Float(-0.123));
 544         pref.putInt("IntValue", 299792458);
 545         pref.flush();
 546
 547         assertEquals(new Float(0.1), pref.getFloat("Value", new Float(0.1)));
 548         assertEquals(new Float(-0.123), pref.getFloat("FloatValue", new Float(0.2)));
 549         assertEquals(new Float(9.109382e-31), pref.getFloat("DoubleValue", new Float(2.14)));
 550         assertEquals(new Float(2.99792448e8), pref.getFloat("IntValue", new Float(5)));
 551
 552         try {
 553             pref.getFloat(null, new Float(0.1));
 554             fail("NullPointerException expected");
 555         } catch (NullPointerException e) {
 556             //expected
 557         }
 558
 559         pref.removeNode();
 560
 561         try {
 562             pref.getFloat("FloatValue", new Float(0.1));
 563             fail("IllegalStateException expected");
 564         } catch (IllegalStateException e) {
 565             //expected
 566         }
 567     }
 568
 569     @TestTargetNew(
 570         level = TestLevel.COMPLETE,
 571         notes = "",
 572         method = "putDouble",
 573         args = {java.lang.String.class, double.class}
 574     )
 575     public void testPutDouble() throws BackingStoreException {
 576         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 577         pref.flush();
 578
 579         assertEquals(new Double(9.10938188e-31), pref.getDouble("DoubleValue", new Double(2.14)));
 580
 581         try {
 582             pref.putDouble(null, new Double(0.1));
 583             fail("NullPointerException expected");
 584         } catch (NullPointerException e) {
 585             //expected
 586         }
 587
 588         int i;
 589         StringBuffer sb = new StringBuffer();
 590
 591         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 592             sb.append('c');
 593         }
 594
 595         try {
 596             pref.putDouble(new String(sb), new Double(0.1));
 597             fail("IllegalArgumentException expected");
 598         } catch (IllegalArgumentException e) {
 599             //expected
 600         }
 601
 602         pref.removeNode();
 603
 604         try {
 605             pref.putDouble("DoubleValue", new Double(0.1));
 606             fail("IllegalStateException expected");
 607         } catch (IllegalStateException e) {
 608             //expected
 609         }
 610     }
 611
 612     @TestTargetNew(
 613         level = TestLevel.COMPLETE,
 614         notes = "",
 615         method = "getDouble",
 616         args = {java.lang.String.class, double.class}
 617     )
 618     public void testGetDouble() throws BackingStoreException {
 619         pref.put("Value", "String");
 620         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 621         pref.putBoolean("BoolValue", true);
 622         pref.putInt("IntValue", 299792458);
 623         pref.flush();
 624
 625         assertEquals(new Double(0.1), pref.getDouble("Value", new Double(0.1)));
 626         assertEquals(new Double(0.2), pref.getDouble("BoolValue", new Double(0.2)));
 627         assertEquals(new Double(9.10938188e-31), pref.getDouble("DoubleValue", new Double(2.14)));
 628         assertEquals(new Double(2.99792458e8), pref.getDouble("IntValue", new Double(5)));
 629
 630         try {
 631             pref.getDouble(null, new Double(0.1));
 632             fail("NullPointerException expected");
 633         } catch (NullPointerException e) {
 634             //expected
 635         }
 636
 637         pref.removeNode();
 638
 639         try {
 640             pref.getDouble("DoubleValue", new Double(0.1));
 641             fail("IllegalStateException expected");
 642         } catch (IllegalStateException e) {
 643             //expected
 644         }
 645     }
 646
 647     @TestTargetNew(
 648         level = TestLevel.COMPLETE,
 649         notes = "",
 650         method = "putByteArray",
 651         args = {java.lang.String.class, byte[].class}
 652     )
 653     public void testPutByteArray() throws BackingStoreException {
 654         byte[] bArray = new byte[]{1, 2, 3, 4, 5};
 655         byte[] array  = null;
 656         int i;
 657         pref.putByteArray("Array", bArray);
 658         pref.flush();
 659
 660         array = pref.getByteArray("Array", null);
 661         assertEquals(bArray.length, array.length);
 662         for(i = 0; i < bArray.length; i++) {
 663             assertEquals(bArray[i], array[i]);
 664         }
 665
 666         try {
 667             pref.putByteArray(null, bArray);
 668             fail("NullPointerException expected");
 669         } catch (NullPointerException e) {
 670             //expected
 671         }
 672
 673         StringBuffer sb = new StringBuffer();
 674
 675         for (i = 0; i < Preferences.MAX_KEY_LENGTH + 1; i++) {
 676             sb.append('c');
 677         }
 678
 679         try {
 680             pref.putByteArray(new String(sb), bArray);
 681             fail("IllegalArgumentException expected");
 682         } catch (IllegalArgumentException e) {
 683             //expected
 684         }
 685
 686         bArray = new byte[Preferences.MAX_VALUE_LENGTH * 3 / 4 + 1];
 687
 688         try {
 689             pref.putByteArray("Big array", bArray);
 690             fail("IllegalArgumentException expected");
 691         } catch (IllegalArgumentException e) {
 692             //expected
 693         }
 694
 695         pref.removeNode();
 696
 697         try {
 698             pref.putByteArray("Array", new byte[10]);
 699             fail("IllegalStateException expected");
 700         } catch (IllegalStateException e) {
 701             //expected
 702         }
 703     }
 704
 705     @TestTargetNew(
 706         level = TestLevel.COMPLETE,
 707         notes = "",
 708         method = "getByteArray",
 709         args = {java.lang.String.class, byte[].class}
 710     )
 711     public void testGetByteArray() throws BackingStoreException {
 712         byte[] bArray = new byte[]{1, 2, 3, 4, 5};
 713         byte[] tmp    = new byte[]{5};
 714         byte[] array  = null;
 715         int i;
 716         pref.put("Value", "String");
 717         pref.putDouble("DoubleValue", new Double(9.10938188e-31));
 718         pref.putByteArray("Array", bArray);
 719         pref.flush();
 720
 721         array = pref.getByteArray("Value", tmp);
 722         assertEquals(tmp.length, array.length);
 723         for(i = 0; i < tmp.length; i++) {
 724             assertEquals(tmp[i], array[i]);
 725         }
 726
 727         array = pref.getByteArray("DoubleValue", tmp);
 728         assertEquals(tmp.length, array.length);
 729         for(i = 0; i < tmp.length; i++) {
 730             assertEquals(tmp[i], array[i]);
 731         }
 732
 733         array = pref.getByteArray("Array", tmp);
 734         assertEquals(bArray.length, array.length);
 735         for(i = 0; i < bArray.length; i++) {
 736             assertEquals(bArray[i], array[i]);
 737         }
 738
 739         try {
 740             pref.getByteArray(null, tmp);
 741             fail("NullPointerException expected");
 742         } catch (NullPointerException e) {
 743             //expected
 744         }
 745
 746         pref.removeNode();
 747
 748         try {
 749             pref.getByteArray("Array", tmp);
 750             fail("IllegalStateException expected");
 751         } catch (IllegalStateException e) {
 752             //expected
 753         }
 754     }
 755
 756     @TestTargets({
 757         @TestTargetNew(
 758             level = TestLevel.COMPLETE,
 759             notes = "keysSpi tested indirectly",
 760             method = "keys",
 761             args = {}
 762         ),
 763         @TestTargetNew(
 764             level = TestLevel.COMPLETE,
 765             notes = "keysSpi tested indirectly",
 766             method = "keysSpi",
 767             args = {}
 768         )
 769     })
 770     public void testKeys() throws BackingStoreException {
 771         String[] keyArray = new String[]{"Value", "DoubleValue", "BoolValue", "IntValue"};
 772         String nodeStr = "New node";
 773         pref.node(nodeStr);
 774         pref.put(keyArray[0], "String");
 775         pref.putDouble(keyArray[1], new Double(9.10938188e-31));
 776         pref.putBoolean(keyArray[2], true);
 777         pref.putInt(keyArray[3], 299792458);
 778         pref.flush();
 779
 780         String[] str = pref.keys();
 781         assertEquals(keyArray.length, str.length);
 782         for(int i = 0; i < str.length; i++) {
 783             boolean flag = false;
 784             for(int j = 0; j < keyArray.length; j++) {
 785                 if (str[i].compareTo(keyArray[j]) == 0) {
 786                     flag = true;
 787                     break;
 788                 }
 789             }
 790             assertTrue(str[i].compareTo(nodeStr) != 0);
 791             assertTrue(flag);
 792         }
 793
 794         pref.removeNode();
 795
 796         try {
 797             pref.keys();
 798             fail("IllegalStateException expected");
 799         } catch(IllegalStateException e) {
 800             //expected
 801         }
 802     }
 803
 804     @TestTargets({
 805         @TestTargetNew(
 806             level = TestLevel.COMPLETE,
 807             notes = "BackingStoreException can not be checked. childrenNamesSpi checked indirectly.",
 808             method = "childrenNames",
 809             args = {}
 810         ),
 811         @TestTargetNew(
 812             level = TestLevel.COMPLETE,
 813             notes = "BackingStoreException can not be checked. childrenNamesSpi checked indirectly.",
 814             method = "childrenNamesSpi",
 815             args = {}
 816         )
 817     })
 818     public void testChildrenNames() throws BackingStoreException {
 819         AbstractPreferences first = (AbstractPreferences) pref.node("First node");
 820         AbstractPreferences second = (AbstractPreferences) pref.node("Second node");
 821
 822         assertEquals(2, pref.childrenNames().length);
 823         assertEquals(0, first.childrenNames().length);
 824         assertEquals(0, second.childrenNames().length);
 825
 826         second.removeNode();
 827
 828         try {
 829             second.childrenNames();
 830             fail("IllegalStateException expected");
 831         } catch (IllegalStateException e) {
 832             //expected
 833         }
 834
 835         pref.removeNode();
 836
 837         try {
 838             first.childrenNames();
 839             fail("IllegalStateException expected");
 840         } catch (IllegalStateException e) {
 841             //expected
 842         }
 843     }
 844
 845     @TestTargetNew(
 846             level = TestLevel.PARTIAL_COMPLETE,
 847             notes = "",
 848             method = "nodeExists",
 849             args = {String.class}
 850     )
 851     public void test_nodeExists() throws BackingStoreException {
 852         AbstractPreferences test = (AbstractPreferences) Preferences.userRoot()
 853                 .node("test");
 854         try {
 855             test.nodeExists(null);
 856             fail("should throw NullPointerException");
 857         } catch (NullPointerException e) {
 858             // Expected
 859         }
 860
 861         test.removeNode();
 862         try {
 863             test.nodeExists(null);
 864             fail("should throw NullPointerException");
 865         } catch (NullPointerException e) {
 866             // Expected
 867         }
 868     }
 869
 870     @TestTargetNew(
 871         level = TestLevel.COMPLETE,
 872         notes = "",
 873         method = "parent",
 874         args = {}
 875     )
 876     public void testParent() throws BackingStoreException {
 877         AbstractPreferences node = (AbstractPreferences) pref.node("First node/sub node");
 878
 879         assertTrue(node.parent().name().compareTo("First node") == 0);
 880
 881         pref.removeNode();
 882
 883         try {
 884             node.parent();
 885             fail("IllegalStateException expected");
 886         } catch (IllegalStateException e) {
 887             //expected
 888         }
 889     }
 890
 891     @TestTargets({
 892         @TestTargetNew(
 893             level = TestLevel.COMPLETE,
 894             notes = "Indirecly checks childSpi",
 895             method = "node",
 896             args = {java.lang.String.class}
 897         ),
 898         @TestTargetNew(
 899             level = TestLevel.COMPLETE,
 900             notes = "Indirecly checks childSpi",
 901             method = "childSpi",
 902             args = {java.lang.String.class}
 903         )
 904     })
 905     public void testNode() throws BackingStoreException {
 906         AbstractPreferences first = (AbstractPreferences) pref.node("First node");
 907         AbstractPreferences second = (AbstractPreferences) pref.node("Second node");
 908
 909         try {
 910             first.node("blabla/");
 911             fail("IllegalArgumentException expected");
 912         } catch (IllegalArgumentException e) {
 913             //expected
 914         }
 915
 916         try {
 917             first.node("///invalid");
 918             fail("IllegalArgumentException expected");
 919         } catch (IllegalArgumentException e) {
 920             //expected
 921         }
 922
 923         StringBuffer sb = new StringBuffer();
 924
 925         for (int i = 0; i < Preferences.MAX_NAME_LENGTH; i++) {
 926             sb.append('c');
 927         }
 928         first.node(new String(sb));
 929         sb.append('c');
 930
 931         try {
 932             first.node(new String(sb));
 933             fail("IllegalArgumentException expected");
 934         } catch (IllegalArgumentException e) {
 935             //expected
 936         }
 937
 938         second.removeNode();
 939
 940         try {
 941             second.node("");
 942             fail("IllegalStateException expected");
 943         } catch (IllegalStateException e) {
 944             //expected
 945         }
 946         pref.removeNode();
 947         try {
 948             first.node("");
 949             fail("IllegalStateException expected");
 950         } catch (IllegalStateException e) {
 951             //expected
 952         }
 953     }
 954
 955     @TestTargets({
 956         @TestTargetNew(
 957             level = TestLevel.COMPLETE,
 958             notes = "getChild tested indirectly",
 959             method = "nodeExists",
 960             args = {java.lang.String.class}
 961         ),
 962         @TestTargetNew(
 963             level = TestLevel.COMPLETE,
 964             notes = "getChild tested indirectly",
 965             method = "getChild",
 966             args = {java.lang.String.class}
 967         )
 968     })
 969     public void testNodeExists() throws BackingStoreException {
 970         AbstractPreferences ap1 = (AbstractPreferences) pref.node("First node");
 971         AbstractPreferences ap2 = (AbstractPreferences) pref.node("Second node");
 972         pref.putInt("IntegerValue", 33);
 973         pref.putBoolean("BoolValue", true);
 974         pref.flush();
 975
 976         assertTrue(pref.nodeExists("First node"));
 977         assertTrue(pref.nodeExists("Second node"));
 978         assertFalse(pref.nodeExists("IntegerValue"));
 979         assertFalse(pref.nodeExists("BoolValue"));
 980         assertFalse(pref.nodeExists("Value"));
 981         assertFalse(pref.nodeExists(nodeName));
 982
 983         try {
 984             pref.nodeExists("///invalid");
 985             fail("IllegalArgumentException expected");
 986         } catch (IllegalArgumentException e) {
 987             //expected
 988         }
 989
 990         pref.removeNode();
 991
 992         try {
 993             pref.nodeExists("Exception");
 994             fail("IllegalStateException expected");
 995         } catch (IllegalStateException e) {
 996             //expected
 997         }
 998     }
 999
1000     @TestTargets({
1001         @TestTargetNew(
1002             level = TestLevel.COMPLETE,
1003             notes = "",
1004             method = "removeNode",
1005             args = {}
1006         ),
1007         @TestTargetNew(
1008             level = TestLevel.COMPLETE,
1009             notes = "",
1010             method = "removeNodeSpi",
1011             args = {}
1012         )
1013     })
1014     public void testRemoveNode() throws BackingStoreException {
1015         String[] nodeArray = new String[]{"First node", "Second node", "Last node"};
1016         int i;
1017         pref.put("Key", "String");
1018         for (i = 0; i < nodeArray.length; i++) {
1019             pref.node(nodeArray[i]);
1020         }
1021         pref.flush();
1022
1023         String[] str = pref.childrenNames();
1024         assertEquals(nodeArray.length, str.length);
1025         for(i = 0; i < nodeArray.length; i++) {
1026             pref.node(nodeArray[i]).removeNode();
1027             str = pref.childrenNames();
1028             assertEquals(nodeArray.length - i - 1, str.length);
1029         }
1030         assertEquals(1, pref.keys().length);
1031         pref.node("Key").removeNode();
1032         assertEquals(1, pref.keys().length);
1033
1034         pref.removeNode();
1035
1036         try {
1037             pref.removeNode();
1038             fail("IllegalStateException expected");
1039         } catch (IllegalStateException e) {
1040             //expected
1041         }
1042
1043         try {
1044             root.removeNode();
1045             fail("UnsupportedOperationException expected");
1046         } catch (UnsupportedOperationException e) {
1047             //expected
1048         }
1049     }
1050
1051     @TestTargetNew(
1052         level = TestLevel.COMPLETE,
1053         notes = "",
1054         method = "name",
1055         args = {}
1056     )
1057     public void testName() {
1058         AbstractPreferences first = (AbstractPreferences) pref.node("First node");
1059         AbstractPreferences second = (AbstractPreferences) pref.node("Second node/sub node");
1060
1061         assertTrue(first.name().compareTo("First node") == 0);
1062         assertFalse(first.name().compareTo("Second node") == 0);
1063         assertTrue(second.name().compareTo("sub node") == 0);
1064     }
1065
1066     @TestTargetNew(
1067         level = TestLevel.COMPLETE,
1068         notes = "",
1069         method = "absolutePath",
1070         args = {}
1071     )
1072     public void testAbsolutePath() {
1073         assertEquals(parent.absolutePath() + "/" + nodeName, pref.absolutePath());
1074         assertEquals(parent.absolutePath() + "/" + "new node", parent.node("new node").absolutePath());
1075     }
1076
1077     @TestTargetNew(
1078         level = TestLevel.COMPLETE,
1079         notes = "",
1080         method = "isUserNode",
1081         args = {}
1082     )
1083     public void testIsUserNode() {
1084         assertTrue(parent.isUserNode());
1085         assertFalse(Preferences.systemRoot().isUserNode());
1086     }
1087
1088     @TestTargets({
1089         @TestTargetNew(
1090             level = TestLevel.COMPLETE,
1091             notes = "Indirectly checks syncSpi",
1092             method = "sync",
1093             args = {}
1094         ),
1095         @TestTargetNew(
1096             level = TestLevel.COMPLETE,
1097             notes = "Indirectly checks syncSpi",
1098             method = "syncSpi",
1099             args = {}
1100         )
1101     })
1102     public void testSync() throws BackingStoreException {
1103         pref.node("new node/sub node");
1104         pref.sync();
1105
1106         pref.removeNode();
1107
1108         try {
1109             pref.sync();
1110             fail("IllegalStateException expected");
1111         } catch (IllegalStateException e) {
1112             //expected
1113         }
1114     }
1115
1116     class MockPreferenceChangeListener implements PreferenceChangeListener {
1117         private boolean flagChange = false;
1118
1119         public void preferenceChange(PreferenceChangeEvent arg0) {
1120             flagChange = true;
1121         }
1122
1123         public boolean isChanged () {
1124             boolean retVal = flagChange;
1125             flagChange = false;
1126             return retVal;
1127         }
1128     }
1129
1130     @TestTargetNew(
1131         level = TestLevel.COMPLETE,
1132         notes = "",
1133         method = "addPreferenceChangeListener",
1134         args = {java.util.prefs.PreferenceChangeListener.class}
1135     )
1136     public void testAddPreferenceChangeListener() throws BackingStoreException {
1137         MockPreferenceChangeListener mpcl = new MockPreferenceChangeListener();
1138         parent.addPreferenceChangeListener(mpcl);
1139         assertFalse(mpcl.isChanged());
1140         pref.node("new node");
1141         pref.flush();
1142         parent.flush();
1143         assertFalse(mpcl.isChanged());
1144         parent.node("new node");
1145         parent.flush();
1146         assertFalse(mpcl.isChanged());
1147         parent.putInt("IntValue", 33);
1148         parent.flush();
1149         parent.flush();
1150         assertTrue(mpcl.isChanged());
1151         assertEquals(33, parent.getInt("IntValue", 22));
1152         parent.flush();
1153         assertFalse(mpcl.isChanged());
1154         assertEquals(22, parent.getInt("Missed Value", 22));
1155         parent.flush();
1156         assertFalse(mpcl.isChanged());
1157     }
1158
1159     @TestTargetNew(
1160         level = TestLevel.COMPLETE,
1161         notes = "",
1162         method = "removePreferenceChangeListener",
1163         args = {java.util.prefs.PreferenceChangeListener.class}
1164     )
1165     public void testRemovePreferenceChangeListener() throws BackingStoreException {
1166         MockPreferenceChangeListener mpcl = new MockPreferenceChangeListener();
1167         parent.addPreferenceChangeListener(mpcl);
1168         assertFalse(mpcl.isChanged());
1169         parent.putInt("IntValue", 33);
1170         parent.flush();
1171         assertTrue(mpcl.isChanged());
1172         parent.removePreferenceChangeListener(mpcl);
1173         parent.putInt("IntValue", 33);
1174         parent.flush();
1175         assertFalse(mpcl.isChanged());
1176     }
1177
1178     class MockNodeChangeListener implements NodeChangeListener {
1179         private boolean flagAdded = false;
1180         private boolean flagRemoved = false;
1181
1182         public void childAdded(NodeChangeEvent arg0) {
1183             flagAdded = true;
1184         }
1185
1186         public void childRemoved(NodeChangeEvent arg0) {
1187             flagRemoved = true;
1188         }
1189
1190         public boolean isAdded() {
1191             return flagAdded;
1192         }
1193
1194         public boolean isRemoved() {
1195             return flagRemoved;
1196         }
1197     }
1198
1199     @TestTargetNew(
1200         level = TestLevel.COMPLETE,
1201         notes = "",
1202         method = "addNodeChangeListener",
1203         args = {java.util.prefs.NodeChangeListener.class}
1204     )
1205     public void testAddNodeChangeListener() throws BackingStoreException {
1206         MockNodeChangeListener mncl = new MockNodeChangeListener();
1207         parent.addNodeChangeListener(mncl);
1208         pref.node("test");
1209         pref.flush();
1210         parent.flush();
1211         assertFalse(mncl.isAdded());
1212         assertFalse(mncl.isRemoved());
1213         pref.removeNode();
1214         parent.flush();
1215         assertFalse(mncl.isAdded());
1216         assertTrue(mncl.isRemoved());
1217         parent.node("new node");
1218         parent.flush();
1219         assertTrue(mncl.isAdded());
1220         assertTrue(mncl.isRemoved());
1221     }
1222
1223     @TestTargetNew(
1224         level = TestLevel.COMPLETE,
1225         notes = "",
1226         method = "removeNodeChangeListener",
1227         args = {java.util.prefs.NodeChangeListener.class}
1228     )
1229     public void testRemoveNodeChangeListener() throws BackingStoreException {
1230         MockNodeChangeListener mncl = new MockNodeChangeListener();
1231         parent.addNodeChangeListener(mncl);
1232         pref.node("test");
1233         pref.flush();
1234         parent.flush();
1235         assertFalse(mncl.isAdded());
1236         assertFalse(mncl.isRemoved());
1237         parent.removeNodeChangeListener(mncl);
1238         pref.removeNode();
1239         parent.flush();
1240         assertFalse(mncl.isAdded());
1241         assertFalse(mncl.isRemoved());
1242         parent.node("new node");
1243         parent.flush();
1244         assertFalse(mncl.isAdded());
1245         assertFalse(mncl.isRemoved());
1246     }
1247
1248     @TestTargets({
1249         @TestTargetNew(
1250             level = TestLevel.COMPLETE,
1251             notes = "BackingStoreException, IOException can not be checked.",
1252             method = "exportNode",
1253             args = {java.io.OutputStream.class}
1254         ),
1255         @TestTargetNew(
1256             level = TestLevel.COMPLETE,
1257             notes = "BackingStoreException, IOException can not be checked.",
1258             method = "flush",
1259             args = {}
1260         ),
1261         @TestTargetNew(
1262             level = TestLevel.COMPLETE,
1263             notes = "BackingStoreException, IOException can not be checked.",
1264             method = "flushSpi",
1265             args = {}
1266         )
1267     })
1268     public void testExportNode() throws BackingStoreException, IOException, InvalidPreferencesFormatException {
1269         AbstractPreferences ap = (AbstractPreferences) pref.node("New node");
1270         pref.putInt("IntValue", 33);
1271         pref.putBoolean("BoolValue", true);
1272         pref.flush();
1273
1274         ByteArrayOutputStream baos = new ByteArrayOutputStream();
1275
1276         pref.exportNode(baos);
1277         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
1278
1279         assertTrue(pref.getBoolean("BoolValue", false));
1280         assertEquals(33, pref.getInt("IntValue", 22));
1281         assertEquals(1, pref.childrenNames().length);
1282
1283         String xmlData = new String(baos.toByteArray());
1284
1285         assertTrue(xmlData.contains("IntValue"));
1286         assertTrue(xmlData.contains("BoolValue"));
1287         assertTrue(xmlData.contains("33"));
1288         assertTrue(xmlData.contains("true"));
1289
1290         pref.removeNode();
1291
1292         try {
1293             pref.exportNode(new ByteArrayOutputStream());
1294             fail("IllegalStateException expected");
1295         } catch (IllegalStateException e) {
1296             //expected
1297         }
1298
1299         try {
1300             pref.getBoolean("BoolValue", false);
1301             fail("IllegalStateException expected");
1302         } catch (IllegalStateException e) {
1303             //expected
1304         }
1305         pref = (AbstractPreferences) parent.node(nodeName);
1306
1307         pref.importPreferences(bais);
1308
1309         assertTrue(pref.getBoolean("BoolValue", false));
1310         assertEquals(33, pref.getInt("IntValue", 22));
1311         assertEquals(0, pref.childrenNames().length);
1312     }
1313
1314     @TestTargets({
1315         @TestTargetNew(
1316             level = TestLevel.COMPLETE,
1317             notes = "BackingStoreException, IOException can not be checked.",
1318             method = "exportSubtree",
1319             args = {java.io.OutputStream.class}
1320         ),
1321         @TestTargetNew(
1322             level = TestLevel.COMPLETE,
1323             notes = "BackingStoreException, IOException can not be checked.",
1324             method = "flush",
1325             args = {}
1326         ),
1327         @TestTargetNew(
1328             level = TestLevel.COMPLETE,
1329             notes = "BackingStoreException, IOException can not be checked.",
1330             method = "flushSpi",
1331             args = {}
1332         )
1333     })
1334     public void testExportSubtree() throws BackingStoreException, IOException, InvalidPreferencesFormatException {
1335         AbstractPreferences ap1 = (AbstractPreferences) pref.node("First node");
1336         AbstractPreferences ap2 = (AbstractPreferences) pref.node("Second node");
1337         pref.putInt("IntegerValue", 33);
1338         pref.putBoolean("BoolValue", true);
1339         pref.flush();
1340
1341         ap1.putInt("FirstIntValue", 11);
1342         ap2.putDouble("DoubleValue", new Double(6.626e-34));
1343
1344         ByteArrayOutputStream baos = new ByteArrayOutputStream();
1345
1346         pref.exportSubtree(baos);
1347         ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
1348
1349         assertTrue(pref.getBoolean("BoolValue", false));
1350         assertEquals(33, pref.getInt("IntegerValue", 22));
1351         assertEquals(2, pref.childrenNames().length);
1352         assertEquals(11, ap1.getInt("FirstIntValue", 22));
1353         assertEquals(new Double(6.626e-34), ap2.getDouble("DoubleValue", new Double (3.14)));
1354
1355         String xmlData = new String(baos.toByteArray());
1356
1357         assertTrue(xmlData.contains("IntegerValue"));
1358         assertTrue(xmlData.contains("BoolValue"));
1359         assertTrue(xmlData.contains("FirstIntValue"));
1360         assertTrue(xmlData.contains("DoubleValue"));
1361         assertTrue(xmlData.contains("33"));
1362         assertTrue(xmlData.contains("true"));
1363         assertTrue(xmlData.contains("11"));
1364         assertTrue(xmlData.contains("6.626E-34"));
1365
1366         pref.removeNode();
1367
1368         try {
1369             pref.exportSubtree(new ByteArrayOutputStream());
1370             fail("IllegalStateException expected");
1371         } catch (IllegalStateException e) {
1372             //expected
1373         }
1374
1375         try {
1376             pref.getBoolean("BoolValue", false);
1377             fail("IllegalStateException expected");
1378         } catch (IllegalStateException e) {
1379             //expected
1380         }
1381         pref = (AbstractPreferences) parent.node(nodeName);
1382         pref.importPreferences(bais);
1383
1384         ap1 = (AbstractPreferences) pref.node("First node");
1385         ap2 = (AbstractPreferences) pref.node("Second node");
1386
1387         assertTrue(pref.getBoolean("BoolValue", false));
1388         assertEquals(33, pref.getInt("IntegerValue", 22));
1389         assertEquals(2, pref.childrenNames().length);
1390         assertEquals(11, ap1.getInt("FirstIntValue", 22));
1391         assertEquals(new Double(6.626e-34), ap2.getDouble("DoubleValue", new Double (3.14)));
1392     }
1393
1394     class MockAbstractPreferences extends AbstractPreferences {
1395         protected MockAbstractPreferences(AbstractPreferences parent, String name) {
1396             super(parent, name);
1397         }
1398
1399         @Override
1400         protected AbstractPreferences childSpi(String name) {
1401             return null;
1402         }
1403
1404         @Override
1405         protected String[] childrenNamesSpi() throws BackingStoreException {
1406             return null;
1407         }
1408
1409         @Override
1410         protected void flushSpi() throws BackingStoreException {
1411         }
1412
1413         @Override
1414         protected String getSpi(String key) {
1415             return null;
1416         }
1417
1418         @Override
1419         protected String[] keysSpi() throws BackingStoreException {
1420             return null;
1421         }
1422
1423         @Override
1424         protected void putSpi(String key, String value) {
1425         }
1426
1427         @Override
1428         protected void removeNodeSpi() throws BackingStoreException {
1429         }
1430
1431         @Override
1432         protected void removeSpi(String key) {
1433         }
1434
1435         @Override
1436         protected void syncSpi() throws BackingStoreException {
1437         }
1438     }
1439
1440     @TestTargetNew(
1441         level = TestLevel.COMPLETE,
1442         notes = "",
1443         method = "AbstractPreferences",
1444         args = {java.util.prefs.AbstractPreferences.class, java.lang.String.class}
1445     )
1446     public void testAbstractPreferences() {
1447         assertNotNull(new MockAbstractPreferences(pref, "node name"));
1448         try {
1449             new MockAbstractPreferences(pref, "node/name");
1450             fail("IllegalArgumentException expected");
1451         } catch (IllegalArgumentException e) {
1452             //expected
1453         }
1454
1455         try {
1456             new MockAbstractPreferences(null, "node");
1457             fail("IllegalArgumentException expected");
1458         } catch (IllegalArgumentException e) {
1459             //expected
1460         }
1461     }
1462
1463     @TestTargetNew(
1464         level = TestLevel.COMPLETE,
1465         notes = "Tested indirectly",
1466         method = "cachedChildren",
1467         args = {}
1468     )
1469     public void testCachedChildren() throws BackingStoreException {
1470         pref.node("First node");
1471         pref.node("Second node");
1472
1473         assertEquals(2, pref.childrenNames().length);
1474     }
1475
1476     @TestTargetNew(
1477         level = TestLevel.COMPLETE,
1478         notes = "No reason to check dummy implementation",
1479         method = "isRemoved",
1480         args = {}
1481     )
1482     public void testIsRemoved() {
1483     }
1484 }