public void testNodeIsReloadedAfterChange() throws Exception {

    public void testNodeIsReloadedAfterChange() throws Exception {

         String key= "key";

        String key= "key";

         String value = "oldValue";

        String value = "oldValue";

         String newValue = "newValue";

        String newValue = "newValue";

         storeEntry(key, value);

        storeEntry(key, value);

         overrideStorageEntryWithNewValue(value, newValue);

        overrideStorageEntryWithNewData(constructNewEntryText(value, newValue));

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

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

         assertNotNull("Reloaded value must not be null", reloadedValue);

        assertNotNull("Reloaded value must not be null", reloadedValue);

         assertEquals("Reloaded value must equals to manually stored value", newValue, reloadedValue);

        assertEquals("Reloaded value must equals to manually stored value", newValue, reloadedValue);

         /*

        /*

          Still need to cope with a memory leak

         Still need to cope with a memory leak

         WeakReference weakPref = new WeakReference(pref);

        WeakReference weakPref = new WeakReference(pref);

         storage = null;

        storage = null;

         pref = null;

        pref = null;

         assertGC("NbPreferences is not GC", weakPref);

        assertGC("NbPreferences is not GC", weakPref);

         */

        */

     }

    }

     private void storeEntry(String keyName, String oldValue) throws BackingStoreException {

    private void storeEntry(String keyName, String oldValue) throws BackingStoreException {

         pref.put(keyName, oldValue);

        pref.put(keyName, oldValue);

         pref.flush();

        pref.flush();

     }

    }

     private void overrideStorageEntryWithNewValue(String oldValue, String newValue) throws IOException {

     private void overrideStorageEntryWithNewData(String newData) throws IOException {

         String newText = constructNewEntryText(oldValue, newValue);         

         storageOutputStream.write(newText.getBytes("ISO-8859-1"));

         storageOutputStream.write(newData.getBytes("ISO-8859-1"));

         storageOutputStream.close();                     

         storageOutputStream.close();

     }

    }

     private String constructNewEntryText(String oldValue, String newValue) throws IOException {

     // UNDER DEVELOPMENT

         String currentText = storage.toPropertiesFile().asText();

     //

         String newText = currentText.replace(oldValue, newValue);

     // NOTE: replacing the file should probably be a method on

         return newText;

     //       PropertiesStorage; or maybe a package method on

     }

     //       NbPreferences for synchronization purposes.

     //

     //       THIS METHOD should probably have an "subnode" argument,

     //                   which (if not null) operates on subnode

     //

    private void XXXoverrideStorageEntryWithNewData(String newData) throws IOException {

        FileObject foOrig = storage.toPropertiesFile();

        FileObject foNew = foOrig.getParent().createData("NewProperties");

        FileLock lock = foNew.lock();

        OutputStream os = foNew.getOutputStream();

        os.write(newData.getBytes("ISO-8859-1"));

        os.close();

        foOrig.rename(lock, foOrig.getName(), foOrig.getExt());

    }

    private String constructNewEntryText(String oldValue, String newValue) throws IOException {

        String currentText = storage.toPropertiesFile().asText();

        String newText = currentText.replace(oldValue, newValue);

        return newText;

    }

    }    

    }

    public void testPreferencesEvents() throws Exception {

        pref.addNodeChangeListener(new NodeListener());

        pref.addPreferenceChangeListener(new PrefListener());

        Preferences child = pref.node("a");

        Thread.currentThread().yield();

        assertTrue("Missing node added event", nodeAddedEvent);

        pref.put("key","value");

        Thread.currentThread().yield();

        assertTrue("Missing preference change event", prefChangedEvent);

        pref.remove("key");

        Thread.currentThread().yield();

        assertTrue("Missing preference removed event", prefRemovedEvent);

        child.removeNode();

        Thread.currentThread().yield();

        assertTrue("Missing node removed event", nodeRemovedEvent);

    }

    // started with testNodeIsReloadedAfterChange (memory leak issue?)

    public void testPreferencesEventsAfterChange1() throws Exception {

        String key= "key";

        String value = "oldValue";

        String newValue = "newValue";

        storeEntry(key, value);

        pref.addPreferenceChangeListener(new PrefListener());

        overrideStorageEntryWithNewData(constructNewEntryText(value, newValue));

        Thread.currentThread().yield();

        assertEquals("Reloaded value must equals to manually stored value",

                     newValue, pref.get(key, null));

        assertTrue("Missing preference change event", prefChangedEvent);

        assertFalse("Unexpected preference removed event", prefRemovedEvent);

    }

    // started with testNodeIsReloadedAfterChange (memory leak issue?)

    public void testPreferencesEventsAfterChange2() throws Exception {

        pref.put("targetKey","targetValue");

        pref.flush();

        // targetPrefs will be loaded as a file.

        String targetPrefs = storage.toPropertiesFile().asText();

        pref.clear();

        pref.put("key","value");

        pref.flush();

        pref.addPreferenceChangeListener(new PrefListener());

        overrideStorageEntryWithNewData(targetPrefs);

        Thread.currentThread().yield();

        assertEquals("not reloaded", "targetValue", pref.get("targetKey", "NONE"));

        assertEquals("not unloaded", "NONE", pref.get("key", "NONE"));

        assertTrue("Missing preference change event", prefChangedEvent);

        assertTrue("Missing preference removed event", prefRemovedEvent);

    }

    private class NodeListener implements NodeChangeListener {

        @Override

        public void childAdded(NodeChangeEvent evt) {

            nodeAddedEvent = true;

        }

        @Override

        public void childRemoved(NodeChangeEvent evt) {

            nodeRemovedEvent = true;

        }

    }

    private class PrefListener implements PreferenceChangeListener {

        @Override

        public void preferenceChange(PreferenceChangeEvent evt) {

            if(evt.getNewValue() != null) {

                prefChangedEvent = true;

            } else {

                prefRemovedEvent = true;

            }

        }

    }