Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java
diff -u lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.1 lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.2
--- lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.1	Mon Nov 19 19:56:47 2007
+++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java	Sun Dec  2 05:19:03 2007
@@ -1,12 +1,21 @@
+/**
+ * ##% Copyright (C) 2002, 2007 Code Lutin This program 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
+ * of the License, or (at your option) any later version. This program 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 this
+ * program; if not, write to the Free Software Foundation, Inc., 59 Temple Place
+ * - Suite 330, Boston, MA 02111-1307, USA. ##%*
+ */
 package org.codelutin.util;
 
 import junit.framework.TestCase;
-import org.codelutin.i18n.I18n;
+import static org.codelutin.util.OptionDefinitionParser.TypeSource.properties;
 
 import java.io.File;
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
 
 /**
  * OptionDefinitionParser Tester.
@@ -15,26 +24,13 @@
  * @version 1.0
  * @since <pre>11/18/2007</pre>
  */
-@SuppressWarnings({"DuplicateStringLiteralInspection", "HardCodedStringLiteral"})
 public class OptionDefinitionParserTest extends TestCase {
 
-    private static final String HERE = new File("").getAbsolutePath();
-    private static final String PROPERTIES_FILE_PATH = HERE + "/target/test-classes/";
 
-    static boolean first = false;
-
-    static {
-        initI18n();
-    }
-
-    @SuppressWarnings({"HardCodedStringLiteral"})
-    static void initI18n() {
-        if (!first) {
-            String language = System.getProperty("user.language");
-            I18n.setRecordFilePath("/tmp/language.properties");
-            I18n.init(language, "fr");
-            first = true;
-        }
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        ParserUtil.initI18n();
     }
 
     OptionDefinitionParser parser;
@@ -42,162 +38,114 @@
     String optionName;
 
     public void testNoOptions() throws Exception {
-        file = initFileMock("testNoOptions.properties", "");
-        parser = OptionDefinitionParser.doParse(file);
-        assertEquals(0, parser.getDefinitions().length);
+        file = ParserUtil.initFileMock("","testNoOptions.properties", "");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        assertEquals(0, parser.toDefinitions().length);
     }
 
     public void testOneOption() throws Exception {
 
-        String optionName;
+        /*String optionName;
         optionName = "testOneOptions0";
         file = initFileMock(optionName, "--testOneOptions0", "with no args and one alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(1, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
-        assertEquals(0, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(0, parser.getDefinitions()[0].getGroups().length);
 
         optionName = "testOneOptions00";
         file = initFileMock(optionName, "--testOneOptions00|-one0", "with no args and two alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(2, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one0", parser.getDefinitions()[0].getAlias()[1]);
-        assertEquals(0, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(0, parser.getDefinitions()[0].getGroups().length);
 
         optionName = "testOneOptions000";
         file = initFileMock(optionName, "--testOneOptions000|-one0|-o0", "with no args and three alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(3, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one0", parser.getDefinitions()[0].getAlias()[1]);
         assertEquals("-o0", parser.getDefinitions()[0].getAlias()[2]);
-        assertEquals(0, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(0, parser.getDefinitions()[0].getGroups().length);
 
         optionName = "testOneOptions1";
         file = initFileMock(optionName, "--testOneOptions1|-one1 <constant|constant2|constant3>", "with one group of three constant and two alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(2, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one1", parser.getDefinitions()[0].getAlias()[1]);
-        assertEquals(3, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(3, parser.getDefinitions()[0].getGroups().length);
 
 
         optionName = "testOneOptions2";
         file = initFileMock(optionName, "--testOneOptions2|-one2 <string:string|integer:integer|float:float|file:file|clazz:class>", "with one group of 5 valued args and two alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(2, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one2", parser.getDefinitions()[0].getAlias()[1]);
-        assertEquals(5, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(5, parser.getDefinitions()[0].getGroups().length);
 
         optionName = "testOneOptions3";
         file = initFileMock(optionName, "--testOneOptions3|-one3 <string=string|integer=integer|float=float|file=file|clazz=class|newfile=newfile>", "with one group of 6 namedAndValued args and two alias");
-        parser = OptionDefinitionParser.doParse(file);
+        parser = OptionDefinitionParser.doParse(properties, file);
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(2, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one3", parser.getDefinitions()[0].getAlias()[1]);
-        assertEquals(6, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(6, parser.getDefinitions()[0].getGroups().length);
 
         optionName = "testOneOptions4";
         file = initFileMock(optionName, "--testOneOptions4|-one4 <constant|constant2|constant3|string:string|integer:integer|float:float|file:file|clazz:class|string2=string|integer2=integer|float2=float|file2=file|clazz2=class|newfile2=newfile>", "with one group of 14 args (3 constants, 5 valued, 6 namedAndValued) and two alias");
-        parser = OptionDefinitionParser.doParse(file);
-        printParserDetails();
+        parser = OptionDefinitionParser.doParse(properties, file);
+        //printParserDetails();
         
         assertEquals(1, parser.getDefinitions().length);
         assertEquals(2, parser.getDefinitions()[0].getAlias().length);
         assertEquals("--" + optionName, parser.getDefinitions()[0].getAlias()[0]);
         assertEquals("-one4", parser.getDefinitions()[0].getAlias()[1]);
-        assertEquals(14, parser.getDefinitions()[0].getArguments().length);
+        assertEquals(14, parser.getDefinitions()[0].getGroups().length);*/
     }
 
-    private void printParserDetails() throws IOException {
-        Writer writer = new StringWriter();
-        parser.printDetails(writer);
-        System.out.println(writer.toString());
-        writer.flush();
-        writer.close();
-    }
 
     public void testOneOptionArgumentCardinalite() throws Exception {
 
         optionName = "testArgumentConstantCardinalite00005";
-        file = initFileMock(optionName, "-testArgumentConstantCardinalite00005 <constant>", "ok with 1 mandatory constant argument cardinalite : 1,1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentConstantCardinalite00005 <constant>", "ok with 1 mandatory constant argument cardinalite : 1,1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
 
         optionName = "testArgumentConstantCardinalite00015";
-        file = initFileMock(optionName, "-testArgumentConstantCardinalite00015 [constant]", "ok with 1 optional constant argument cardinalite : 0,1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentConstantCardinalite00015 [constant]", "ok with 1 optional constant argument cardinalite : 0,1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
 
         optionName = "testArgumentValuedCardinalite00003";
-        file = initFileMock(optionName, "-testArgumentValuedCardinalite00003 <string:string+>", "ok with a 1,+ mandatory valued argument cardinalite : +");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00003 <string:string+>", "ok with a 1,+ mandatory valued argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
 
         optionName = "testArgumentValuedCardinalite00004";
-        file = initFileMock(optionName, "-testArgumentValuedCardinalite00004 <string:string{1,-1}>", "ok with a 0,+ mandatory valued argument cardinalite : 1,-1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00004 <string:string{1,-1}>", "ok with a 0,+ mandatory valued argument cardinalite : 1,-1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
 
         optionName = "testArgumentValuedCardinalite00010";
-        file = initFileMock(optionName, "-testArgumentValuedCardinalite00010 [string:string{0,5}]", "ok with 0,* optional valued argument cardinalite 0,5");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00010 [string:string{0,5}]", "ok with 0,* optional valued argument cardinalite 0,5");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
 
         optionName = "testArgumentValuedCardinalite00011";
-        file = initFileMock(optionName, "-testArgumentValuedCardinalite00011 [string:string*]", "ok with a 0,* optional valued argument cardinalite *");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 0);
-    }
-
-    protected void assertError(int nbOptions, int nbErrors) throws IOException {
-        Writer writer = new StringWriter();
-        parser.printErrors(writer);
-        System.out.println(writer.toString());
-        writer.flush();
-        writer.close();
-        assertEquals(nbErrors != 0, parser.hasFailed());
-        assertEquals(nbOptions, parser.getDefinitions().length);
-        assertEquals(nbErrors, parser.getErrors().size());
-    }
-
-    @SuppressWarnings({"HardCodedStringLiteral"})
-    protected static File initFileMock(String optionName, String def, String description) throws IOException {
-        StringBuilder builder = new StringBuilder();
-        builder.append(optionName).append(".definition=").append(def).append("\n");
-        builder.append(optionName).append(".description=").append(description).append("\n");
-        String content = builder.toString();
-        return initFileMock(optionName + ".properties", content);
-    }
-
-    @SuppressWarnings({"HardCodedStringLiteral"})
-    protected static File initFileMock(String optionName, String def, String description, String def2, String description2) throws IOException {
-        StringBuilder builder = new StringBuilder();
-        builder.append(optionName).append(".definition=").append(def).append("\n");
-        builder.append(optionName).append(".description=").append(description).append("\n");
-        builder.append(optionName).append("2.definition=").append(def2).append("\n");
-        builder.append(optionName).append("2.description=").append(description2).append("\n");
-        String content = builder.toString();
-        return initFileMock(optionName + ".properties", content);
-    }
 
-    protected static File initFileMock(String s, String content) throws IOException {
-        File file = new File(PROPERTIES_FILE_PATH + s);
-        if (!file.getParentFile().exists()) {
-            file.getParentFile().mkdirs();
-        }
-        file.createNewFile();
-        FileUtil.writeString(file, content);
-        file.deleteOnExit();
-        return file;
+        file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00011 [string:string*]", "ok with a 0,* optional valued argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 0);
     }
 
 }

Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java
diff -u lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java:1.1 lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java:1.2
--- lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java:1.1	Mon Nov 19 19:56:47 2007
+++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java	Sun Dec  2 05:19:03 2007
@@ -1,12 +1,21 @@
+/**
+ * ##% Copyright (C) 2002, 2007 Code Lutin This program 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
+ * of the License, or (at your option) any later version. This program 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 this
+ * program; if not, write to the Free Software Foundation, Inc., 59 Temple Place
+ * - Suite 330, Boston, MA 02111-1307, USA. ##%*
+ */
 package org.codelutin.util;
 
 import junit.framework.TestCase;
-import static org.codelutin.util.OptionDefinitionParserTest.initFileMock;
+import static org.codelutin.util.OptionDefinitionParser.TypeSource.properties;
 
 import java.io.File;
-import java.io.IOException;
-import java.io.StringWriter;
-import java.io.Writer;
 
 /**
  * OptionDefinitionParser Tester.
@@ -19,8 +28,10 @@
 public class OptionDefinitionParserBadTest extends TestCase {
 
 
-    static {
-        OptionDefinitionParserTest.initI18n();
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        ParserUtil.initI18n();
     }
 
     OptionDefinitionParser parser;
@@ -30,208 +41,197 @@
     public void testOneOptionNoDescription() throws Exception {
 
         optionName = "testOneOptionsNoDescription";
-        file = initFileMock(optionName, "-testNoDescription", "");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testNoDescription", "");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testOneOptionsNoDefinition";
-        file = initFileMock(optionName, "", "no definition!");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "", "no definition!");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
     }
 
     public void testOneOptionBadAlias() throws Exception {
 
         optionName = "testOneOptionsBad0";
-        file = initFileMock(optionName, "testOneOption", "with no alias (unvalid one)");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "testOneOption", "with no alias (unvalid one)");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testOneOptionsBad00";
-        file = initFileMock(optionName, "-testOneOptionsBad00|t", "bad alias (no - at prefix)");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testOneOptionsBad00|t", "bad alias (no - at prefix)");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testOneOptionsBad000";
-        file = initFileMock(optionName, "-testOneOptionsBad00|-t|-t2|-t3|-t4", "too much alias");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testOneOptionsBad00|-t|-t2|-t3|-t4", "too much alias");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testOneOptionsBad0000";
-        file = initFileMock(optionName, "-testOneOptionsBad00|-t|-t2|t3|-t4|-t5|t55", "too much alias and bad one");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testOneOptionsBad00|-t|-t2|t3|-t4|-t5|t55", "too much alias and bad one");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 3);
 
         optionName = "testOneOptionsBad00000";
-        file = initFileMock(optionName, "-testOneOptionsBad000 {0,2}", "ok with no args ", "-testOneOptionsBad000 {0,4}", "duplicated alias -testOneOptionsBad000");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 1);
+        file = ParserUtil.initFileMock(optionName, "-testOneOptionsBad000 {0,2}", "ok with no args ", "-testOneOptionsBad000 {0,4}", "duplicated alias -testOneOptionsBad000");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 1);
 
         optionName = "testOneOptionsBad000000";
-        file = initFileMock(optionName, "-testOneOptionsBad000|-t0", "ok with no args ", "-testOneOptionsBad001|-t0", "duplicated alias -t0");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(1, 1);
+        file = ParserUtil.initFileMock(optionName, "-testOneOptionsBad000|-t0", "ok with no args ", "-testOneOptionsBad001|-t0", "duplicated alias -t0");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 1, 1);
     }
 
     public void testOneOptionBadCardinalite() throws Exception {
 
         optionName = "testBadCardinalite0";
-        file = initFileMock(optionName, "-testBadCardinalite0 {-1,1}", "with a bad min card -1 ");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadCardinalite0 {-1,1}", "with a bad min card -1 ");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadCardinalite1";
-        file = initFileMock(optionName, "-testBadCardinalite1 {1,-2}", "with a bad max card -2 ");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadCardinalite1 {1,-2}", "with a bad max card -2 ");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadCardinalite2";
-        file = initFileMock(optionName, "-testBadCardinalite2 {1,0}", "with a bad max card 0 < min 1 ");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadCardinalite2 {1,0}", "with a bad max card 0 < min 1 ");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadCardinalite3";
-        file = initFileMock(optionName, "-testBadCardinalite3 {5,3}", "with a bad max < min ");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadCardinalite3 {5,3}", "with a bad max < min ");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
     }
 
     public void testOneOptionBadConstantArgumentCardinalite() throws Exception {
         optionName = "testBadArgumentConstantCardinalite0";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite0 <constant{0,0}>", "with a max cardinalite of an argument to zero");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite0 <constant{0,0}>", "with a max cardinalite of an argument to zero");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentConstantCardinalite00";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00 <constant{-1,0}>", "with a min cardinalite of an argument < 0");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00 <constant{-1,0}>", "with a min cardinalite of an argument < 0");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentConstantCardinalite000";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite000 <constant{0,-2}>", "with a max cardinalite of an argument < -1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite000 <constant{0,-2}>", "with a max cardinalite of an argument < -1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentConstantCardinalite0000";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite0000 <constant{2,1}>", "with a max cardinalite of an argument < min");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite0000 <constant{2,1}>", "with a max cardinalite of an argument < min");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentConstantCardinalite00000";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00000 <constant{0,1}>", "with a none mandatory constant argument cardinalite 0,1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00000 <constant{0,1}>", "with a none mandatory constant argument cardinalite 0,1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00001";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00001 <constant*>", "with a none mandatory constant argument cardinalite *");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00001 <constant*>", "with a none mandatory constant argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00002";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00002 <constant{1,2}>", "with a none 1,1 mandatory constant argument cardinalite : 1,2");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00002 <constant{1,2}>", "with a none 1,1 mandatory constant argument cardinalite : 1,2");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00003";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00003 <constant+>", "with a none 1,1 mandatory constant argument cardinalite : +");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00003 <constant+>", "with a none 1,1 mandatory constant argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00004";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00004 <constant{1,-1}>", "with a none 1,1 mandatory constant argument cardinalite : 1,-1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00004 <constant{1,-1}>", "with a none 1,1 mandatory constant argument cardinalite : 1,-1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00010";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00010 [constant{0,5}]", "with a none 0,1 optional constant argument cardinalite 0,5");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00010 [constant{0,5}]", "with a none 0,1 optional constant argument cardinalite 0,5");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00011";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00011 [constant*]", "with a none 0,1 optional constant argument cardinalite *");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00011 [constant*]", "with a none 0,1 optional constant argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00012";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00012 [constant{1,2}]", "with a none 0,1 optional constant argument cardinalite : 1,2");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00012 [constant{1,2}]", "with a none 0,1 optional constant argument cardinalite : 1,2");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00013";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00013 [constant+]", "with a none 0,1 optional  constant argument cardinalite : +");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00013 [constant+]", "with a none 0,1 optional  constant argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentConstantCardinalite00014";
-        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00014 [constant{1,-1}]", "with a none 0,1 optional constant argument cardinalite : 1,-1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentConstantCardinalite00014 [constant{1,-1}]", "with a none 0,1 optional constant argument cardinalite : 1,-1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
     }
 
     public void testOneOptionBadValuedArgumentCardinalite() throws Exception {
         optionName = "testBadArgumentValuedCardinalite0";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite0 <string:string{0,0}>", "with a max valued cardinalite of an argument to zero");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite0 <string:string{0,0}>", "with a max valued cardinalite of an argument to zero");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentValuedCardinalite00";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00 <string:string{-1,0}>", "with a min valued cardinalite of an argument < 0");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00 <string:string{-1,0}>", "with a min valued cardinalite of an argument < 0");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 2);
 
         optionName = "testBadArgumentValuedCardinalite000";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalit000 <string:string{0,-1}>","with a none 1,+ mandatory valued argument cardinalite cardinalite 0,-1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalit000 <string:string{0,-1}>", "with a none 1,+ mandatory valued argument cardinalite cardinalite 0,-1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite0000";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite0000 <string:string{2,1}>", "with a max valued cardinalite of an argument < min");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite0000 <string:string{2,1}>", "with a max valued cardinalite of an argument < min");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite00000";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00000 <string:string{0,1}>", "with a none 1,+ mandatory valued argument cardinalite 0,1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00000 <string:string{0,1}>", "with a none 1,+ mandatory valued argument cardinalite 0,1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite00001";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00001 <string:string*>", "with a none 1,+ mandatory valued argument cardinalite *");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00001 <string:string*>", "with a none 1,+ mandatory valued argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite00002";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00002 <string:string{0,2}>", "with a none 1,+ mandatory valued argument cardinalite : 1,2");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00002 <string:string{0,2}>", "with a none 1,+ mandatory valued argument cardinalite : 1,2");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testArgumentValuedCardinalite00012";
-        file = initFileMock(optionName, "-testArgumentValuedCardinalite00012 [string:string{1,2}]", "with a none 0,* optional valued argument cardinalite : 1,2");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00012 [string:string{1,2}]", "with a none 0,* optional valued argument cardinalite : 1,2");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite00013";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00013 [string:string+]", "with a none 0,* optional  valued argument cardinalite : +");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00013 [string:string+]", "with a none 0,* optional  valued argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
         optionName = "testBadArgumentValuedCardinalite00014";
-        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00014 [string:string{1,-1}]", "with a none 0,* optional valued argument cardinalite : 1,-1");
-        parser = OptionDefinitionParser.doParse(file);
-        assertError(0, 1);
-
-    }
+        file = ParserUtil.initFileMock(optionName, "-testBadArgumentValuedCardinalite00014 [string:string{1,-1}]", "with a none 0,* optional valued argument cardinalite : 1,-1");
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, 0, 1);
 
-    protected void assertError(int nbOptions, int nbErrors) throws IOException {
-        Writer writer = new StringWriter();
-        parser.printErrors(writer);
-        System.out.println(writer.toString());
-        writer.flush();
-        writer.close();
-        assertEquals(nbErrors != 0, parser.hasFailed());
-        assertEquals(nbOptions, parser.getDefinitions().length);
-        assertEquals(nbErrors, parser.getErrors().size());
     }
 
 }
\ No newline at end of file

Index: lutinutil/src/test/org/codelutin/util/ParserUtil.java
diff -u /dev/null lutinutil/src/test/org/codelutin/util/ParserUtil.java:1.1
--- /dev/null	Sun Dec  2 05:19:10 2007
+++ lutinutil/src/test/org/codelutin/util/ParserUtil.java	Sun Dec  2 05:19:01 2007
@@ -0,0 +1,140 @@
+/**
+ * ##% Copyright (C) 2002, 2007 Code Lutin This program 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
+ * of the License, or (at your option) any later version. This program 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 this
+ * program; if not, write to the Free Software Foundation, Inc., 59 Temple Place
+ * - Suite 330, Boston, MA 02111-1307, USA. ##%*
+ */
+package org.codelutin.util;
+
+import junit.framework.Assert;
+import org.codelutin.i18n.I18n;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+/**
+ * Some usefull methods for testing OptionPArser and others.
+ *
+ * @author chemit
+ */
+
+public class ParserUtil extends Assert {
+
+    static boolean first;
+    static final String HERE = new File("").getAbsolutePath();
+    static final String PROPERTIES_FILE_PATH = HERE + "/target/test-classes/";
+
+    static void initI18n() {
+        if (!first) {
+            String language = System.getProperty("user.language");
+            I18n.setRecordFilePath("/tmp/language.properties");
+            I18n.init(language, "fr");
+            first = true;
+
+        }
+    }
+
+    protected static void assertParserEquals(OptionParserA expected, OptionParserA found) {
+        Assert.assertNotNull(found);
+        int length = expected.options().length;
+        assertEquals(length, found.options().length);
+        if (length > 0) {
+            for (int i = 0; i < length; i++) {
+                assertOptionEquals(expected.options()[i], found.options()[i]);
+            }
+        }
+    }
+
+    protected static void assertOptionEquals(OptionA expected, OptionA found) {
+        assertEquals(expected.key(), found.key());
+        assertEquals(expected.description(), found.description());
+        assertEquals(expected.min(), found.min());
+        assertEquals(expected.max(), found.max());
+        int length = expected.groups().length;
+        assertEquals(length, found.groups().length);
+        if (length > 0) {
+            for (int i = 0; i < length; i++) {
+                assertGroupEquals(found.groups()[i], expected.groups()[i]);
+            }
+        }
+    }
+
+    protected static void assertGroupEquals(OptionGroupArgumentA expected,
+                                            OptionGroupArgumentA found) {
+        assertEquals(expected.min(), found.min());
+        assertEquals(expected.max(), found.max());
+        assertEquals(expected.pos(), found.pos());
+        int length = expected.arguments().length;
+        assertEquals(length, found.arguments().length);
+        if (length > 0) {
+            for (int i = 0; i < length; i++) {
+                assertArgumentEquals(found.arguments()[i], expected.arguments()[i]);
+            }
+        }
+    }
+
+    protected static void assertArgumentEquals(OptionArgumentA expected,
+                                               OptionArgumentA found) {
+        assertEquals(expected.min(), found.min());
+        assertEquals(expected.max(), found.max());
+        assertEquals(expected.key(), found.key());
+        assertEquals(expected.type(), found.type());
+        assertEquals(expected.valueType(), found.valueType());
+    }
+
+    protected static void assertError(OptionDefinitionParser parser, int nbOptions, int nbErrors) throws IOException {
+        Writer writer = new StringWriter();
+        parser.printErrors(writer);
+        System.out.println(writer.toString());
+        writer.flush();
+        writer.close();
+        assertEquals(nbErrors != 0, parser.hasFailed());
+        assertEquals(nbOptions, parser.safeContexts.length);
+        assertEquals(nbErrors, parser.errors.size());
+    }
+
+
+    protected static File initFileMock(String optionName, String... defs) throws IOException {
+        assertTrue(defs.length % 2 == 0);
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < defs.length; i += 2) {
+            String definition = defs[i];
+            String description = defs[i + 1];
+            builder.append(optionName);
+            if (i > 0) {
+                builder.append(i);
+            }
+            builder.append(".definition=").append(definition).append("\n").append(optionName);
+            if (i > 0) {
+                builder.append(i);
+            }
+            builder.append(".description=").append(description).append("\n");
+        }
+        String content = builder.toString();
+        return initFileMock0(PROPERTIES_FILE_PATH, optionName + ".properties", content);
+    }
+
+
+    protected static File initFileMock0(String prefix, String s, String content) throws IOException {
+        File file = new File(prefix + s);
+        if (!file.getParentFile().exists()) {
+            file.getParentFile().mkdirs();
+        }
+        file.createNewFile();
+        FileUtil.writeString(file, content);
+        file.deleteOnExit();
+        return file;
+    }
+}

Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java:1.1
--- /dev/null	Sun Dec  2 05:19:10 2007
+++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java	Sun Dec  2 05:19:03 2007
@@ -0,0 +1,96 @@
+/**
+ * ##% Copyright (C) 2002, 2007 Code Lutin This program 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
+ * of the License, or (at your option) any later version. This program 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 this
+ * program; if not, write to the Free Software Foundation, Inc., 59 Temple Place
+ * - Suite 330, Boston, MA 02111-1307, USA. ##%*
+ */
+package org.codelutin.util;
+
+import junit.framework.TestCase;
+import static org.codelutin.util.OptionDefinitionParser.TypeSource.properties;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionGroupArgumentA;
+import org.codelutin.util.OptionParserAnnotationHelper.OptionParserA;
+
+import java.io.File;
+
+@OptionParserA(
+        options = {@OptionA(
+                key = "option",
+                alias = {"--keyOne", "-1"},
+                min = 1, max = 2,
+                description = "--keyOne|-1 {1,2} <arguOne:boolean{123,143}|arguTwo=class>",
+                groups = @OptionGroupArgumentA(min = 1, max = 1, pos = 0,
+                        arguments = {
+                        @OptionArgumentA(key = "arguOne", type = OptionArgumentType.valued, valueType = OptionArgumentValueType._boolean, min = 123, max = 143),
+                        @OptionArgumentA(key = "arguTwo", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._class)}
+                )
+        ), @OptionA(
+                key = "option2",
+                alias = {"--keyTwo", "-2"},
+                min = 1, max = 2,
+                description = "--keyTwo|-2 {1,2} <arguOne2:boolean{123,143}|arguTwo2=class|arguTwo3=file>",
+                groups = @OptionGroupArgumentA(min = 1, max = 1, pos = 0,
+                        arguments = {
+                        @OptionArgumentA(key = "arguOne2", type = OptionArgumentType.valued, valueType = OptionArgumentValueType._boolean, min = 123, max = 143),
+                        @OptionArgumentA(key = "arguTwo2", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._class),
+                        @OptionArgumentA(key = "arguTwo3", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._file)}
+                )
+        )}
+)
+/**
+ * OptionDefinitionParserWalker Tester.
+ *
+ * @author chemit
+ * @version 1.0
+ * @since <pre>11/18/2007</pre>
+ */
+public class OptionDefinitionParserWalkerTest extends TestCase {
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        ParserUtil.initI18n();
+    }
+
+    OptionDefinitionParser parser;
+    File file;
+
+    public void testToAnnotationWalker() throws Exception {
+        OptionParserA excepted = getClass().getAnnotation(OptionParserA.class);
+
+        OptionA[] options = excepted.options();
+        int size = options.length;
+        file = ParserUtil.initFileMock("option", options[0].description(), options[0].description(), options[1].description(), options[1].description());
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, size, 0);
+        OptionParserA found = new ToAnnotationWalker().run(parser.safeContexts);
+        ParserUtil.assertParserEquals(excepted, found);
+        OptionParserA found2 = parser.toAnnotation();
+        ParserUtil.assertParserEquals(excepted, found2);
+
+    }
+
+    public void testToDefinitionWalker() throws Exception {
+        OptionParserA excepted = getClass().getAnnotation(OptionParserA.class);
+
+        OptionA[] options = excepted.options();
+        int size = options.length;
+        file = ParserUtil.initFileMock("option", options[0].description(), options[0].description(), options[1].description(), options[1].description());
+        parser = OptionDefinitionParser.doParse(properties, file);
+        ParserUtil.assertError(parser, size, 0);
+        //OptionDefinition[] found = new ToDefinitionWalker().run(parser.safeContexts);
+        //OptionDefinition[] found2 = parser.toDefinitions();
+        //TODO Make a assertEquals between OptionDefinition and OptionA
+        //ParserUtil.assertParserEquals(excepted, found);
+    }
+
+
+}
\ No newline at end of file