Index: lutinutil/src/test/org/codelutin/util/MyPropertiesTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/util/MyPropertiesTest.java:1.1
--- /dev/null	Sun Dec  9 20:04:28 2007
+++ lutinutil/src/test/org/codelutin/util/MyPropertiesTest.java	Sun Dec  9 20:04:23 2007
@@ -0,0 +1,337 @@
+package org.codelutin.util;
+
+import junit.framework.TestCase;
+import org.codelutin.i18n.I18n;
+import org.codelutin.util.MyPropertiesUtil.MyPropertyDef;
+import org.codelutin.util.MyPropertiesUtil.MyPropertyKey;
+
+import java.util.Properties;
+
+/**
+ * MyProperties Tester.
+ *
+ * @author chemit
+ * @version 1.0
+ * @since <pre>12/08/2007</pre>
+ */
+public class MyPropertiesTest extends TestCase {
+    static {
+        // init I18N
+        I18n.init(System.getProperty("user.language"),
+                System.getProperty("user.country"));
+    }
+
+    enum MyPropertiesTestDef implements MyPropertyDef {
+        BOOLEAN("key.boolean", Boolean.class),
+        INTEGER("key.integer", Integer.class),
+        LONG("key.long", Long.class),
+        STRING("key.string", String.class),
+        MYKEY("key.mykey", MyPropertiesTestDef.class);
+
+        <D> MyPropertiesTestDef(String key, Class<D> type) {
+            MyPropertyKeyManager.registerKey(new MyPropertyKey<D>(this, key, type));
+        }
+    }
+
+    enum MyPropertiesTestDef2 implements MyPropertyDef {
+        BOOLEAN("key2.boolean", Boolean.class),
+        INTEGER("key2.integer", Integer.class),
+        LONG("key2.long", Long.class),
+        FILE("key2.file", java.io.File.class),
+        STRING("key2.key2", MyPropertiesTestDef2.class),
+        MYKEY("key2.key2", MyPropertiesTestDef2.class);
+
+        <D> MyPropertiesTestDef2(String key, Class<D> type) {
+            try {
+                MyPropertyKeyManager.registerKey(new MyPropertyKey<D>(this, key, type));
+                if (ordinal() == 5) {
+                    // the key is duplicated, so we must not reach here
+                    fail();
+                } else {
+                    assertTrue(true);
+                }
+            } catch (IllegalArgumentException e) {
+                if (ordinal() == 5) {
+                    // duplicate key
+                    assertTrue(true);
+                } else {
+                    fail();
+                }
+            }
+        }
+    }
+
+    enum MyPropertiesTestDef3 implements MyPropertyDef {
+        BOOLEAN("key2.boolean", Boolean.class),
+        INTEGER("key2.integer", Integer.class),
+        LONG("key2.long", Long.class),
+        FILE("key2.file", java.io.File.class),
+        STRING("key2.string", String.class),
+        MYKEY("key2.unknown", MyPropertyDef.class);
+
+        <D> MyPropertiesTestDef3(String key, Class<D> type) {
+            try {
+                MyPropertyKeyManager.registerKey(new MyPropertyKey<D>(this, key, type));
+                if (ordinal() == 5) {
+                    // no convertor found , so we must not reach here
+                    fail();
+                } else {
+                    assertTrue(true);
+                }
+            } catch (IllegalArgumentException e) {
+                if (ordinal() == 5) {
+                    // no convertor found
+                    assertTrue(true);
+                } else {
+                    fail();
+                }
+            }
+        }
+    }
+
+    MyProperties<MyPropertiesTestDef> properties;
+
+    Class<?> type;
+    String key;
+    Object val;
+    Object valDef;
+    int size;
+    int miss;
+
+    public void testRegisterKey() throws Exception {
+        MyPropertiesTestDef.values();
+        MyPropertiesTestDef2.values();
+        MyPropertiesTestDef3.values();
+    }
+
+    public void testConstructor() throws Exception {
+        properties = MyProperties.newInstance(MyPropertiesTestDef.class);
+
+        size = 0;
+        miss = MyPropertiesTestDef.values().length;
+
+        assertSize();
+
+        System.out.println(properties);
+
+        properties.clear();
+
+    }
+
+    public void testSetProperty() throws Exception {
+
+        properties = MyProperties.newInstance(MyPropertiesTestDef.class);
+        MyPropertiesTestDef[] testDefs = MyPropertiesTestDef.values();
+        size = 0;
+        miss = testDefs.length;
+
+        assertSize();
+
+        Object val;
+        Object valDef;
+        val = Boolean.FALSE;
+        valDef = Boolean.TRUE;
+
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, valDef);
+        assertKeyEntry("key.boolean", Boolean.class, null, valDef);
+        properties.setProperty(MyPropertiesTestDef.BOOLEAN, val);
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, valDef);
+        size++;
+        miss--;
+        assertKeyEntry("key.boolean", Boolean.class, val, val);
+
+        val = -100;
+        valDef = 10;
+        getKeyDatas(MyPropertiesTestDef.INTEGER, valDef);
+        assertKeyEntry("key.integer", Integer.class, null, valDef);
+        properties.setProperty(MyPropertiesTestDef.INTEGER, val);
+        getKeyDatas(MyPropertiesTestDef.INTEGER, valDef);
+        size++;
+        miss--;
+        assertKeyEntry("key.integer", Integer.class, val, val);
+
+        val = MyPropertiesTestDef.BOOLEAN;
+        valDef = MyPropertiesTestDef.STRING;
+        getKeyDatas(MyPropertiesTestDef.MYKEY, valDef);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, null, valDef);
+        properties.setProperty(MyPropertiesTestDef.MYKEY, val);
+        getKeyDatas(MyPropertiesTestDef.MYKEY, valDef);
+        size++;
+        miss--;
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, val, val);
+
+        val = null;
+        getKeyDatas(MyPropertiesTestDef.MYKEY, valDef);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, MyPropertiesTestDef.BOOLEAN, MyPropertiesTestDef.BOOLEAN);
+        properties.setProperty(MyPropertiesTestDef.MYKEY, val);
+        getKeyDatas(MyPropertiesTestDef.MYKEY, valDef);
+        size--;
+        miss++;
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, val, valDef);
+
+        val = 10;
+        //try {
+        properties.setProperty(MyPropertiesTestDef.MYKEY, val);
+        //    fail();
+        //} catch (IllegalArgumentException e) {
+        //    assertTrue(true);
+        //}
+        getKeyDatas(MyPropertiesTestDef.MYKEY, valDef);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, null, valDef);
+        System.out.println(properties);
+    }
+
+
+    public void testLoad() throws Exception {
+        properties = MyProperties.newInstance(MyPropertiesTestDef.class);
+        MyPropertiesTestDef[] testDefs = MyPropertiesTestDef.values();
+
+        Properties props = new Properties();
+        props.put("key.boolean", false);
+        props.put("key.string", "hello");
+        props.put("key.integer", -100);
+        props.put("key.long", (long) 1000);
+        props.put("key.mykey", MyPropertiesTestDef.BOOLEAN);
+
+        properties.load(props);
+
+        Object val;
+
+        size = 5;
+        miss = testDefs.length - 5;
+        val = Boolean.FALSE;
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, Boolean.TRUE);
+        assertKeyEntry("key.boolean", Boolean.class, val, val);
+
+        val = -100;
+        getKeyDatas(MyPropertiesTestDef.INTEGER, 10);
+        assertKeyEntry("key.integer", Integer.class, val, val);
+
+        val = (long) 1000;
+        getKeyDatas(MyPropertiesTestDef.LONG, 10);
+        assertKeyEntry("key.long", Long.class, val, val);
+
+        val = "hello";
+        getKeyDatas(MyPropertiesTestDef.STRING, "yo");
+        assertKeyEntry("key.string", String.class, val, val);
+
+        val = MyPropertiesTestDef.BOOLEAN;
+        getKeyDatas(MyPropertiesTestDef.MYKEY, MyPropertiesTestDef.STRING);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, val, val);
+
+        System.out.println(properties);
+
+        properties.clear();
+
+        size -= 5;
+        miss += 5;
+        assertSize();
+
+        props.put("key.integer", "200");
+        props.put("key.long", "2000");
+        props.put("key.boolean", "false");
+        properties.load(props);
+        size = 5;
+        miss -= 5;
+        assertSize();
+
+        val = 200;
+        getKeyDatas(MyPropertiesTestDef.INTEGER, 10);
+        assertKeyEntry("key.integer", Integer.class, val, val);
+
+        val = (long) 2000;
+        getKeyDatas(MyPropertiesTestDef.LONG, 10);
+        assertKeyEntry("key.long", Long.class, val, val);
+
+        val = false;
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, true);
+        assertKeyEntry("key.boolean", Boolean.class, val, val);
+
+        properties.clear();
+
+        props.put("key.mykey", 10);
+        properties.load(props);
+        System.out.println(properties);
+
+        size = 4;
+        miss = testDefs.length - 4;
+
+        assertSize();
+        assertEquals(1, properties.getUnsafeData().size());
+
+        val = Boolean.FALSE;
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, Boolean.TRUE);
+        assertKeyEntry("key.boolean", Boolean.class, val, val);
+
+        val = 200;
+        getKeyDatas(MyPropertiesTestDef.INTEGER, 10);
+        assertKeyEntry("key.integer", Integer.class, val, val);
+
+        val = (long) 2000;
+        getKeyDatas(MyPropertiesTestDef.LONG, 10);
+        assertKeyEntry("key.long", Long.class, val, val);
+
+        val = false;
+        getKeyDatas(MyPropertiesTestDef.BOOLEAN, true);
+        assertKeyEntry("key.boolean", Boolean.class, val, val);
+
+        val = "hello";
+        getKeyDatas(MyPropertiesTestDef.STRING, "yo");
+        assertKeyEntry("key.string", String.class, val, val);
+
+        val = null;
+        getKeyDatas(MyPropertiesTestDef.MYKEY, MyPropertiesTestDef.STRING);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, val, MyPropertiesTestDef.STRING);
+
+        properties.clear();
+
+        props.put("key.mykeyAZ", 10);
+        properties.load(props);
+        System.out.println(properties);
+
+        size = 4;
+        miss = testDefs.length - 4;
+        assertSize();
+        assertEquals(2, properties.getUnsafeData().size());
+
+        properties.clear();
+
+        props.put("key.mykey", 1);
+        properties.load(props);
+        System.out.println(properties);
+
+        size = 5;
+        miss = testDefs.length - 5;
+        assertSize();
+        assertEquals(1, properties.getUnsafeData().size());
+        val = MyPropertiesTestDef.INTEGER;
+        getKeyDatas(MyPropertiesTestDef.MYKEY, MyPropertiesTestDef.STRING);
+        assertKeyEntry("key.mykey", MyPropertiesTestDef.class, val, val);
+
+        System.out.println(properties);
+
+    }
+
+    private void assertKeyEntry(String key, Class<?> type, Object val, Object valDef) {
+        assertEquals(key, this.key);
+        assertTrue(type.isAssignableFrom(this.type));
+        assertEquals(val, this.val);
+        assertEquals(valDef, this.valDef);
+        assertSize();
+    }
+
+    private void assertSize() {
+        assertEquals(size == 0, properties.isEmpty());
+        assertEquals(miss == 0, properties.isFull());
+        assertEquals(size, properties.size());
+        assertEquals(size, properties.getKeys().size());
+        assertEquals(miss, properties.getMissingKeys().size());
+    }
+
+    private void getKeyDatas(MyPropertiesTestDef def, Object valDef) {
+        type = properties.getType(def);
+        key = properties.getKey(def);
+        val = properties.getProperty(def);
+        this.valDef = properties.getProperty(def, valDef);
+    }
+}