public void testPreferencesEvents() throws Exception {
    storage.toFolder(true);
    FileUtil.getConfigRoot().addRecursiveListener(new FileListener());
    pref.addNodeChangeListener(new NodeListener());

    String newPath = "a/b/c";
    String[] paths = newPath.split("/");
    FileObject fo = null;
    FileObject fo0 = null;
    for (int i = 0; i < paths.length; i++) {
      String path = paths[i];
      fo = FileUtil.createFolder((fo == null) ? FileUtil.getConfigRoot() : fo, path);
      if (i == 0) {
        fo0 = fo;
      }
      nodeAddedEvent.await();
      assertEquals("Missing node added event", 0, nodeAddedEvent.getCount());
      nodeAddedEvent = new CountDownLatch(1);

      Preferences pref2 = pref.node(fo.getPath());
      pref2.addNodeChangeListener(new NodeListener());
    }

    FileObject fo1 = FileUtil.createData(fo, "a.properties");
    nodeAddedEvent.await();
    assertEquals("Missing node added event", 0, nodeAddedEvent.getCount());

    nodeRemovedEvent = new CountDownLatch(paths.length + 1);
    fo0.delete();
    nodeRemovedEvent.await();
    assertEquals("Missing node removed event", 0, nodeRemovedEvent.getCount());
  }
 public void testNode() throws BackingStoreException {
   assertNull(storage.toFolder());
   assertNull(storage.toPropertiesFile());
   pref.flush();
   assertNull(storage.toFolder());
   assertNull(storage.toPropertiesFile());
   pref.put("key", "value");
 }
  public void testRemove() throws BackingStoreException {
    assertNull(storage.toFolder());
    assertNull(storage.toPropertiesFile());

    pref.put("key", "value");
    pref.flush();
    assertNotNull(storage.toPropertiesFile());
    pref.remove("key");
    assertTrue(pref.properties.isEmpty());
    pref.flush();
    assertNull(storage.toPropertiesFile());
  }
  public void testValueChangeFireEvent() throws Exception {
    pref.put("key0", "value10");
    pref.addPreferenceChangeListener(new PrefListener());
    pref.sync();
    assertEquals("value10", pref.get("key0", null));
    overrideStorageEntryWithNewData("key0=value0");

    assertEquals("value0", pref.get("key0", null));
    prefChangedEvent.await();
    assertEquals(
        "No preference changed event was fired for value change", 0, prefChangedEvent.getCount());
  }
 public void testNode5() throws BackingStoreException {
   Preferences child = pref.node("a");
   child.put("key", "value");
   child.flush();
   assertNotNull(storage.toFolder());
   assertNull(storage.toPropertiesFile());
 }
  public void testRemoveParentNode() throws BackingStoreException {
    assertNull(storage.toFolder());
    assertNull(storage.toPropertiesFile());

    Preferences subnode = pref.node("subnode");
    assertNull(storage.toFolder());
    assertNull(storage.toPropertiesFile());
    subnode.put("key", "value");
    subnode.flush();
    assertNotNull(storage.toFolder());
    assertNull(storage.toPropertiesFile());
    subnode.removeNode();
    pref.flush();
    assertNull(storage.toPropertiesFile());
    assertNull(storage.toFolder());
    assertFalse(storage.existsNode());
  }
  public void testPreferencesEvents2() throws Exception {
    pref.addNodeChangeListener(new NodeListener());
    pref.addPreferenceChangeListener(new PrefListener());

    Preferences child = pref.node("a");
    nodeAddedEvent.await();
    assertEquals("Missing node added event", 0, nodeAddedEvent.getCount());
    pref.put("key", "value");
    prefChangedEvent.await();
    assertEquals("Missing preference change event", 0, prefChangedEvent.getCount());
    pref.remove("key");
    prefRemovedEvent.await();
    assertEquals("Missing preference removed event", 0, prefRemovedEvent.getCount());
    child.removeNode();
    nodeRemovedEvent.await();
    assertEquals("Missing node removed event", 0, nodeRemovedEvent.getCount());
  }
  public void testInvalidChildrenNames() throws Exception {
    NbPreferences subnode = pref;
    assertNotNull(subnode);
    PropertiesStorage ps = (PropertiesStorage) pref.fileStorage;
    FileObject fold = ps.toFolder(true);
    assertNotNull(FileUtil.createData(fold, "a/b/c/invalid1"));
    subnode.sync();
    assertEquals(0, subnode.childrenNames().length);

    assertNotNull(FileUtil.createData(fold, "a/b/c/invalid2.huh"));
    subnode.sync();
    assertEquals(0, subnode.childrenNames().length);

    assertNotNull(FileUtil.createData(fold, "a/b/c/invalid3.properties.huh"));
    subnode.sync();
    assertEquals(0, subnode.childrenNames().length);

    assertNotNull(FileUtil.createData(fold, "a/b/c/valid.properties"));
    subnode.sync();
    assertEquals(1, subnode.childrenNames().length);
    assertEquals("a", subnode.childrenNames()[0]);
  }
  public void testKeyRemovalFireEvent() throws Exception {
    pref.put("key", "value");
    pref.put("key0", "value10");
    pref.put("key1", "value11");

    pref.addPreferenceChangeListener(new PrefListener());
    pref.sync();
    assertEquals("value10", pref.get("key0", null));
    deleteStorageEntry("key0=value10");

    assertEquals(null, pref.get("key0", null));
    prefRemovedEvent.await();
    assertEquals(
        "No preference changed event was fired for key removal", 0, prefRemovedEvent.getCount());
  }
  public void testNodeIsReloadedAfterChange() throws Exception {
    String key = "key";
    String value = "oldValue";
    String newValue = "newValue";
    storeEntry(key, value);
    overrideStorageEntryWithNewValue(value, newValue);

    String reloadedValue = pref.get(key, null);

    assertNotNull("Reloaded value must not be null", reloadedValue);
    assertEquals("Reloaded value must equals to manually stored value", newValue, reloadedValue);
    /*
     Still need to cope with a memory leak

    WeakReference weakPref = new WeakReference(pref);
    storage = null;
    pref = null;
    assertGC("NbPreferences is not GC", weakPref);
    */

  }
  @RandomlyFails // FSException: Invalid lock (from flush)
  public void testRemoveNode() throws BackingStoreException {
    assertNull(storage.toFolder());
    assertNull(storage.toPropertiesFile());

    pref.put("key", "value");
    pref.node("subnode").put("key", "value");
    pref.flush();
    assertNotNull(storage.toPropertiesFile());
    assertNotNull(storage.toFolder());
    pref.removeNode();
    pref.flush();
    assertNull(storage.toPropertiesFile());
    assertNull(storage.toFolder());
    assertFalse(storage.existsNode());
    pref.sync();
  }
 public void testChildrenNames() throws Exception {
   Preferences subnode = pref.node("c1");
   subnode.put("k", "v");
   subnode.flush();
   subnode = pref.node("c2");
   subnode.put("k", "v");
   subnode.flush();
   subnode = pref.node("c3/c4");
   subnode.put("k", "v");
   subnode.flush();
   assertEquals(
       new TreeSet<String>(Arrays.asList("c1", "c2", "c3")),
       new TreeSet<String>(Arrays.asList(storage.childrenNames())));
   pref.node("c2").removeNode();
   assertEquals(
       new TreeSet<String>(Arrays.asList("c1", "c3")),
       new TreeSet<String>(Arrays.asList(storage.childrenNames())));
   pref.node("c3").removeNode();
   assertEquals(
       Collections.singleton("c1"), new TreeSet<String>(Arrays.asList(storage.childrenNames())));
   pref.node("c1").removeNode();
   assertEquals(
       Collections.emptySet(), new TreeSet<String>(Arrays.asList(storage.childrenNames())));
 }
 private void storeEntry(String keyName, String oldValue) throws BackingStoreException {
   pref.put(keyName, oldValue);
   pref.flush();
 }
 public void testNode4() throws BackingStoreException {
   pref.node("a");
   testNode();
 }
 public void testNode2() throws BackingStoreException {
   testNode();
   pref.flush();
   assertNotNull(storage.toPropertiesFile());
 }