Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.1
--- /dev/null	Mon Nov 19 19:56:52 2007
+++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java	Mon Nov 19 19:56:47 2007
@@ -0,0 +1,203 @@
+package org.codelutin.util;
+
+import junit.framework.TestCase;
+import org.codelutin.i18n.I18n;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+/**
+ * OptionDefinitionParser Tester.
+ *
+ * @author chemit
+ * @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;
+        }
+    }
+
+    OptionDefinitionParser parser;
+    File file;
+    String optionName;
+
+    public void testNoOptions() throws Exception {
+        file = initFileMock("testNoOptions.properties", "");
+        parser = OptionDefinitionParser.doParse(file);
+        assertEquals(0, parser.getDefinitions().length);
+    }
+
+    public void testOneOption() throws Exception {
+
+        String optionName;
+        optionName = "testOneOptions0";
+        file = initFileMock(optionName, "--testOneOptions0", "with no args and one alias");
+        parser = OptionDefinitionParser.doParse(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);
+
+        optionName = "testOneOptions00";
+        file = initFileMock(optionName, "--testOneOptions00|-one0", "with no args and two alias");
+        parser = OptionDefinitionParser.doParse(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);
+
+        optionName = "testOneOptions000";
+        file = initFileMock(optionName, "--testOneOptions000|-one0|-o0", "with no args and three alias");
+        parser = OptionDefinitionParser.doParse(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);
+
+        optionName = "testOneOptions1";
+        file = initFileMock(optionName, "--testOneOptions1|-one1 <constant|constant2|constant3>", "with one group of three constant and two alias");
+        parser = OptionDefinitionParser.doParse(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);
+
+
+        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);
+        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);
+
+        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);
+        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);
+
+        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();
+        
+        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);
+    }
+
+    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);
+
+        optionName = "testArgumentConstantCardinalite00015";
+        file = initFileMock(optionName, "-testArgumentConstantCardinalite00015 [constant]", "ok with 1 optional constant argument cardinalite : 0,1");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        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);
+
+        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);
+
+        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;
+    }
+
+}

Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java:1.1
--- /dev/null	Mon Nov 19 19:56:52 2007
+++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadTest.java	Mon Nov 19 19:56:47 2007
@@ -0,0 +1,237 @@
+package org.codelutin.util;
+
+import junit.framework.TestCase;
+import static org.codelutin.util.OptionDefinitionParserTest.initFileMock;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+
+/**
+ * OptionDefinitionParser Tester.
+ *
+ * @author chemit
+ * @version 1.0
+ * @since <pre>11/18/2007</pre>
+ */
+@SuppressWarnings({"DuplicateStringLiteralInspection", "HardCodedStringLiteral"})
+public class OptionDefinitionParserBadTest extends TestCase {
+
+
+    static {
+        OptionDefinitionParserTest.initI18n();
+    }
+
+    OptionDefinitionParser parser;
+    File file;
+    String optionName;
+
+    public void testOneOptionNoDescription() throws Exception {
+
+        optionName = "testOneOptionsNoDescription";
+        file = initFileMock(optionName, "-testNoDescription", "");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(0, 1);
+
+        optionName = "testOneOptionsNoDefinition";
+        file = initFileMock(optionName, "", "no definition!");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testOneOptionsBad00";
+        file = initFileMock(optionName, "-testOneOptionsBad00|t", "bad alias (no - at prefix)");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(0, 1);
+
+        optionName = "testOneOptionsBad000";
+        file = initFileMock(optionName, "-testOneOptionsBad00|-t|-t2|-t3|-t4", "too much alias");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        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);
+
+        optionName = "testOneOptionsBad000000";
+        file = initFileMock(optionName, "-testOneOptionsBad000|-t0", "ok with no args ", "-testOneOptionsBad001|-t0", "duplicated alias -t0");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testBadCardinalite1";
+        file = initFileMock(optionName, "-testBadCardinalite1 {1,-2}", "with a bad max card -2 ");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testBadCardinalite3";
+        file = initFileMock(optionName, "-testBadCardinalite3 {5,3}", "with a bad max < min ");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testBadArgumentConstantCardinalite00";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00 <constant{-1,0}>", "with a min cardinalite of an argument < 0");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(0, 1);
+
+        optionName = "testBadArgumentConstantCardinalite000";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite000 <constant{0,-2}>", "with a max cardinalite of an argument < -1");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(0, 1);
+
+        optionName = "testBadArgumentConstantCardinalite0000";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite0000 <constant{2,1}>", "with a max cardinalite of an argument < min");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(0, 1);
+
+        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);
+
+        optionName = "testBadArgumentConstantCardinalite00001";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00001 <constant*>", "with a none mandatory constant argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testBadArgumentConstantCardinalite00003";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00003 <constant+>", "with a none 1,1 mandatory constant argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        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);
+
+        optionName = "testBadArgumentConstantCardinalite00011";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00011 [constant*]", "with a none 0,1 optional constant argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        optionName = "testBadArgumentConstantCardinalite00013";
+        file = initFileMock(optionName, "-testBadArgumentConstantCardinalite00013 [constant+]", "with a none 0,1 optional  constant argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+    }
+
+    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);
+
+        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);
+
+        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);
+
+        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);
+
+        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);
+
+        optionName = "testBadArgumentValuedCardinalite00001";
+        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00001 <string:string*>", "with a none 1,+ mandatory valued argument cardinalite *");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+        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);
+
+        optionName = "testBadArgumentValuedCardinalite00013";
+        file = initFileMock(optionName, "-testBadArgumentValuedCardinalite00013 [string:string+]", "with a none 0,* optional  valued argument cardinalite : +");
+        parser = OptionDefinitionParser.doParse(file);
+        assertError(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);
+
+    }
+
+    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