RFC: simple preference api test

[Mario Torre <neugens at limasoftware dot net>]

Hi!

This is a simple and by no means complete test for java.util.prefs
This is my first attempt at learning mauve, so hopefully everything is
right.

Comments are welcome.
Mario

2006-06-17  neugens  <neugens@nirvana.limasoftware>

	* gnu/testlet/java/util/prefs: new package added.
	* gnu/testlet/java/util/prefs/PreferenceTest.java:
	new test.

-- 
Lima Software, SO.PR.IND. s.r.l.
http://www.limasoftware.net/
pgp key: http://subkeys.pgp.net/

Please, support open standards:
http://opendocumentfellowship.org/petition/
http://www.nosoftwarepatents.com/

Index: gnu/testlet/java/util/prefs/PreferenceTest.java
===================================================================
RCS file: gnu/testlet/java/util/prefs/PreferenceTest.java
diff -N gnu/testlet/java/util/prefs/PreferenceTest.java
--- /dev/null	1 Jan 1970 00:00:00 -0000
+++ gnu/testlet/java/util/prefs/PreferenceTest.java	1 Jan 1970 00:00:00 -0000
@@ -0,0 +1,357 @@
+/*
+ * PreferenceTest.java -- simple test for java.utils.prefs Copyright (C) 2006
+ * Lima Software. This file is part of Mauve.
+ * 
+ * Mauve is free software; you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License as published by the Free Software
+ * Foundation; either version 2, or (at your option) any later version.
+ * 
+ * Mauve is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * Mauve; see the file COPYING. If not, write to the Free Software Foundation,
+ * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ * 
+ */
+
+// Tags: JDK1.4
+package gnu.testlet.java.util.prefs;
+
+import java.util.prefs.BackingStoreException;
+
+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 gnu.testlet.TestHarness;
+import gnu.testlet.Testlet;
+
+/**
+ * This simple test just read and write a set of preference. Does not assume a
+ * particular backend.
+ * 
+ * @author Mario Torre <neugens@limasoftware.net>
+ */
+public class PreferenceTest implements Testlet
+{
+	/**
+	 * The expected full name of this preference node. <strong>Note:</strong>
+	 * change it if you move this class, it always reflects the package name.
+	 */
+	private static final String FULL_PATH = "/gnu/testlet/java/util/prefs";
+
+	/**
+	 * Default key used for tests.
+	 */
+	private static final String KEY = "AppName";
+
+	/**
+	 * Default value for the test key.
+	 */
+	private static final String VALUE =
+			"GNU Classpath - Preference API Test Case";
+
+	/**
+	 * Defines if we want debug information on the default debug log or not.
+	 * Enable the if you need it or leave disabled for normal tests.
+	 */
+	private static final boolean DEBUG = true;
+
+	/* Test Harness */
+	protected TestHarness harness = null;
+
+	/** Preference */
+	private Preferences prefs = null;
+
+	public void test(TestHarness harness)
+	{
+		this.harness = harness;
+		
+		// initiliaze tests, call it before any other method of this class
+		setup();
+		
+		if (DEBUG) printInfo();
+
+		// run tests
+		testAbsolutePath();
+
+		// clear the preference tree, to be sure it does not contains
+		// keys we will use
+		testClear();
+
+		testPut();
+		testListener();
+		
+		testChildren();
+	}
+
+	/**
+	 * Setup the preference api backend.
+	 */
+	private void setup()
+	{
+		//System.setProperty("java.util.prefs.PreferencesFactory",
+		//		"gnu.java.util.prefs.GConfBasedFactory");
+		
+		this.prefs = Preferences.userNodeForPackage(PreferenceTest.class);
+	}
+
+	private void testAbsolutePath()
+	{
+		this.harness.checkPoint("absolutePath()");
+
+		String absolutePath = this.prefs.absolutePath();
+		print("Absolute path: " + absolutePath);
+
+		this.harness.check(FULL_PATH.compareTo(absolutePath) == 0);
+	}
+
+	private void testClear()
+	{
+		this.harness.checkPoint("testClear()");
+
+		try {
+			this.prefs.clear();
+
+		} catch (BackingStoreException e) {
+			print(e.getLocalizedMessage());
+			this.harness.fail("testClear()");
+		}
+
+		this.harness.check(true);
+	}
+
+	/**
+	 * Put the default key on the preference node, then get it and check the
+	 * result to see if the preference api is actually capable of storing
+	 * preferences.
+	 */
+	private void testPut()
+	{
+		this.harness.checkPoint("testPut()");
+
+		this.prefs.put(KEY, VALUE);
+
+		// suggest a sync to try to avoid memory caching.
+		try {
+			this.prefs.sync();
+
+		} catch (BackingStoreException e) {
+			print(e.getLocalizedMessage());
+			this.harness.fail("testPut(), call to sync");
+		}
+
+		String value = this.prefs.get(KEY, "Wrong value for key: " + KEY
+				+ ", expected: " + VALUE);
+
+		print("Key (" + KEY + "): " + value);
+		this.harness.check(VALUE.compareTo(value) == 0);
+	}
+
+	/**
+	 * Add a series of children to this node, put some preferences inside them
+	 * and retrieve everything, checking that the preference backend correctly
+	 * handles the tree structure of the entries under the current node.
+	 * <strong>Note</strong>: this test removes the preference node.
+	 */
+	private void testChildren()
+	{
+		this.harness.checkPoint("testAddChildren()");
+
+		String absolutePath = null;
+
+		// add 3 new nodes, these will be direct children of the current node
+
+		// node 1
+		Preferences pref1 = this.prefs.node("children_1");
+		this.harness.check("children_1".compareTo(pref1.name()) == 0);
+		absolutePath = pref1.absolutePath();
+		this.harness.check(
+				(FULL_PATH + "/children_1").compareTo(absolutePath) == 0);
+
+		// node 2
+		Preferences pref2 = this.prefs.node("children_2");
+		this.harness.check("children_2".compareTo(pref2.name()) == 0);
+		absolutePath = pref2.absolutePath();
+		this.harness.check(
+				(FULL_PATH + "/children_2").compareTo(absolutePath) == 0);
+
+		// node 3
+		Preferences pref3 = this.prefs.node("children_3");
+		this.harness.check("children_3".compareTo(pref3.name()) == 0);
+		absolutePath = pref3.absolutePath();
+		this.harness.check(
+				(FULL_PATH + "/children_3").compareTo(absolutePath) == 0);
+
+		// now add a preference key to each of these new nodes
+		pref1.put("key1", "value1");
+		pref2.put("key2", "value2");
+		pref3.put("key3", "value3");
+
+		// add a subnode for child #1
+		Preferences child1 = pref1.node("subPreference1");
+		this.harness.check("subPreference1".compareTo(child1.name()) == 0);
+		absolutePath = child1.absolutePath();
+		this.harness.check((FULL_PATH + "/children_1/" + "subPreference1")
+				.compareTo(absolutePath) == 0);
+		
+		child1.put("key1-child1", "some value");
+		
+		// retrieve the list of children of the root node
+		this.harness.checkPoint("testAddChildren() - check new children");
+		String[] expResult = { "children_1", "children_2", "children_3" };
+		if (!listChildren(this.prefs, expResult)) {
+			this.harness.fail("testAddChildren(), children listing error");
+		}
+		
+		this.harness.checkPoint("testAddChildren() - check subnodes");
+		expResult = new String[] { "subPreference1"};
+		if (!listChildren(pref1, expResult)) {
+			this.harness.fail("testAddChildren(), children listing error");
+		}
+		
+		// clean everything
+        try {
+			this.prefs.removeNode();
+			this.prefs.flush();
+			
+		} catch (BackingStoreException e) {
+			print(e.getLocalizedMessage());
+			this.harness.fail("testAddChildren(), call to clear()");
+		}
+		
+		// to check that the node is empty we simply call childrenNames on it
+		// this operation should fail because the node does not exist anymore
+		this.harness.checkPoint("testAddChildren() - checking emptyness");
+		try {
+			this.prefs.childrenNames();
+			this.harness.fail("The node should not exist anymore!");
+			
+		} catch (IllegalStateException e) {
+			this.harness.check(true);
+			
+		} catch (BackingStoreException e) {
+			print(e.getLocalizedMessage());
+			this.harness.fail("The node should not exist anymore!");
+		}
+	}
+
+	private boolean listChildren(Preferences pref, String[] expResult)
+	{
+		boolean _res = false;
+		
+		try {
+        	String[] result  = pref.childrenNames();
+        	
+        	print("Resuls length: " + result.length + ", expected: "
+        			+ expResult.length);
+        	this.harness.check(result.length == expResult.length);
+        	
+        	for (int i = 0; i < expResult.length; i++) {
+        		print("result[" + i + "] = " + result[i] + ", expected = "
+        				+ expResult[i]);
+        		this.harness.check(result[i], expResult[i]);
+            }
+
+        	_res =  true;
+        	
+        } catch (BackingStoreException e) {
+			print(e.getLocalizedMessage());
+			this.harness.fail("call to childrenNames()");
+		}
+		
+		return _res;
+	}
+	
+	private void testListener()
+	{
+		this.harness.checkPoint("testListener()");
+		
+		PreferenceListener listener = new PreferenceListener();
+
+		this.harness.checkPoint("testListener() - adding listeners");
+		this.prefs.addNodeChangeListener(listener);
+		this.prefs.addPreferenceChangeListener(listener);
+	
+		// store this, key, read it then remove it
+		this.harness.checkPoint("testListener() - inserting key");
+		
+		this.prefs.put("new_key", "some value");
+		String key = this.prefs.get("new_key", "Wrong! Wrong! Wrong!");
+		this.harness.check(key, "some value");
+		
+		this.harness.checkPoint("testListener() - updating key");
+		
+		this.prefs.put("new_key", "some other value");
+		key = this.prefs.get("new_key", "Wrong! Wrong! Wrong!");
+		this.harness.check(key, "some other value");
+		
+		this.harness.checkPoint("testListener() - removing listeners");
+		
+		this.prefs.removeNodeChangeListener(listener);
+		this.prefs.removePreferenceChangeListener(listener);
+	
+		this.harness.checkPoint("testListener() - removing key");
+		
+		this.prefs.remove("new_key");
+	}
+	
+	/**
+	 * Prints on screen some information about the class we are about to test.
+	 * This can be useful for debugging, ant to check if a particoular backend
+	 * is enabled.
+	 */
+	private void printInfo()
+	{
+		String backendName = System.getProperty(
+				"java.util.prefs.PreferencesFactory",
+				"No backend registered, using default backend");
+		String vendor = System.getProperty("java.vendor");
+
+		this.harness.debug(vendor);
+		this.harness.debug(backendName);
+	}
+
+	private void print(String message)
+	{
+		if (DEBUG) harness.debug(message);
+	}
+	
+	private class PreferenceListener
+			implements NodeChangeListener, PreferenceChangeListener
+	{
+		public void childAdded(NodeChangeEvent event)
+		{
+			PreferenceTest.this.harness.check(true);
+			
+			print("Child added!");
+			String name = event.getChild().name();
+			print("name: " + name);
+		}
+
+		public void childRemoved(NodeChangeEvent event)
+		{
+			PreferenceTest.this.harness.check(true);
+			
+			print("Child removed!");
+			String name = event.getChild().name();
+			print("name: " + name);
+		}
+
+		public void preferenceChange(PreferenceChangeEvent event)
+		{
+			PreferenceTest.this.harness.check(true);
+			
+			print("Preference changed!");
+			String name  = event.getNode().name();
+			String value = event.getNewValue();
+			print("name: " + name);
+			print("value: " + value);
+		}
+	}
+}