Index: lutinutil/src/test/org/codelutin/option/ParserUtilForTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/option/ParserUtilForTest.java:1.1
--- /dev/null	Sun Dec 30 22:51:23 2007
+++ lutinutil/src/test/org/codelutin/option/ParserUtilForTest.java	Sun Dec 30 22:51:18 2007
@@ -0,0 +1,105 @@
+/**
+ * ##% 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.option;
+
+import junit.framework.Assert;
+import org.codelutin.i18n.I18n;
+import org.codelutin.log.LutinLogFactory;
+import org.codelutin.option.def.DefinitionParser;
+import org.codelutin.util.FileUtil;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.StringWriter;
+import java.io.Writer;
+import java.util.Arrays;
+
+/**
+ * Some usefull methods for testing OptionPArser and others.
+ *
+ * @author chemit
+ */
+
+public class ParserUtilForTest extends Assert {
+
+    static boolean first;
+    static final String HERE = new File("").getAbsolutePath();
+    static final String PROPERTIES_FILE_PATH = HERE + "/target/gen/test-classes/";
+
+    public static void initI18n() {
+        if (!first) {
+            I18n.init2(System.getProperty("user.language", "fr"), System.getProperty("user.country", "FR"), "ISO-8859-1");
+            System.setProperty("org.apache.commons.logging.LogFactory", LutinLogFactory.class.getName());
+            first = true;
+
+        }
+    }
+
+    public static void assertError(DefinitionParser 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.getOptions().length);
+        assertEquals(nbErrors, parser.getErrors().length);
+    }
+
+    public static void assertError(OptionParser parser, int nbOptions, int nbErrors, int nbUnused) throws IOException {
+        Writer writer = new StringWriter();
+        writer.append("\n=============================================== nbOptions:");
+        writer.append(String.valueOf(nbOptions));
+        writer.append(", nbErrors:").append(String.valueOf(nbErrors));
+        writer.append(", nbUnused:").append(String.valueOf(nbUnused)).append(", args:").append(Arrays.toString(parser.getArguments())).append("\n");
+        parser.printErrors(writer);
+        System.out.println(writer.toString());
+        writer.flush();
+        writer.close();
+        assertEquals(nbErrors != 0, parser.hasFailed());
+        assertEquals(nbOptions, parser.getNbOptions());
+        assertEquals(nbUnused, parser.getUnusedArguments().length);
+        assertEquals(nbErrors, parser.getErrors().length);
+    }
+
+
+    public static File initFileMock(String key, String type, String... defs) throws IOException {
+        //assertTrue(defs.length % 2 == 0);
+        StringBuilder builder = new StringBuilder();
+        for (int i = 0; i < defs.length; i++) {
+            String definition = defs[i];
+            //STRING description = defs[i + 1];
+            builder.append(key);
+            if (i > 0) {
+                builder.append(i);
+            }
+            builder.append(".").append(type).append(".definition=").append(definition).append("\n").append(key);
+            if (i > 0) {
+                builder.append(i);
+            }
+        }
+        String content = builder.toString();
+        return initFileMock0(PROPERTIES_FILE_PATH, key + ".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/option/ParserTest.java
diff -u /dev/null lutinutil/src/test/org/codelutin/option/ParserTest.java:1.1
--- /dev/null	Sun Dec 30 22:51:23 2007
+++ lutinutil/src/test/org/codelutin/option/ParserTest.java	Sun Dec 30 22:51:18 2007
@@ -0,0 +1,256 @@
+package org.codelutin.option;
+
+import junit.framework.TestCase;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import static org.codelutin.option.def.ArgumentType.constant;
+import static org.codelutin.option.def.ArgumentValueType.STRING;
+import org.codelutin.option.def.OptionDefinition;
+import org.codelutin.option.def.OptionDefinitionBuilder;
+
+import java.io.IOException;
+import java.io.StringWriter;
+import java.util.Arrays;
+
+/**
+ * OptionParser Tester.
+ *
+ * @author chemit
+ * @version 1.0
+ * @since <pre>11/14/2007</pre>
+ */
+public class ParserTest extends TestCase {
+
+    static private Log log = LogFactory.getLog(ParserTest.class);
+
+    static {
+        ParserUtilForTest.initI18n();
+    }
+
+    static int counter = 0;
+
+    public static class OptionHelp extends Option {
+        public OptionHelp(String usedAlias, Argument... arguments) {
+            super(usedAlias, arguments);
+        }
+    }
+
+    public static class OptionHelp1 extends Option {
+        public OptionHelp1(String usedAlias, Argument... arguments) {
+            super(usedAlias, arguments);
+        }
+    }
+
+    public static class AbstractHelpAction extends OptionAction<OptionHelp, MyParser> {
+        public AbstractHelpAction(MyParser parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+    }
+
+    public static class AbstractHelp1Action extends OptionAction<OptionHelp1, MyParser1> {
+        public AbstractHelp1Action(MyParser1 parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+    }
+
+    public static class AbstractMandatory1Action extends OptionAction<Option, MyParser1> {
+        public AbstractMandatory1Action(MyParser1 parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+    }
+
+    public static class AbstractMandatory2Action extends OptionAction<Option, MyParser1> {
+        public AbstractMandatory2Action(MyParser1 parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+    }
+
+    public static class AbstractOptional1Action extends OptionAction<Option, MyParser1> {
+        public AbstractOptional1Action(MyParser1 parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+    }
+
+    public static class AbstractOptional2Action extends OptionAction<Option, MyParser1> {
+        public AbstractOptional2Action(MyParser1 parser) {
+            super(parser);
+        }
+
+        protected void run() throws Exception {
+            log.info(this + " : " + option);
+            counter++;
+        }
+
+        @Override
+        protected void afterAll(Option... options) {
+            log.info(Arrays.toString(options));
+        }
+
+        @Override
+        protected void beforeAll(Option... options) {
+            log.info(Arrays.toString(options));
+        }
+    }
+
+
+    static class MyParser extends OptionParser {
+        static public final OptionKey<OptionHelp, MyParser, AbstractHelpAction> HELP_OPTION_KEY;
+
+        static {
+            OptionDefinition[] definitions = buildDefinitions(MyParser.class);
+            HELP_OPTION_KEY = new OptionKey<OptionHelp, MyParser, AbstractHelpAction>("help", OptionHelp.class, AbstractHelpAction.class, "", definitions[0]);
+        }
+
+        protected static void buildDefinitions(OptionDefinitionBuilder builder) {
+            builder.beginBuilder(1);
+            builder.beginOption(0);
+            builder.endOption("help", 0, 1, "--help", "-h");
+        }
+    }
+
+    static class MyParser1 extends OptionParser {
+        static public final OptionKey<OptionHelp1, MyParser1, AbstractHelp1Action> HELP_OPTION_KEY;
+        static public final OptionKey<Option, MyParser1, AbstractMandatory1Action> MANDATORY1_OPTION_KEY;
+        static public final OptionKey<Option, MyParser1, AbstractMandatory2Action> MANDATORY2_OPTION_KEY;
+        static public final OptionKey<Option, MyParser1, AbstractOptional1Action> OPTIONAL1_OPTION_KEY;
+        static public final OptionKey<Option, MyParser1, AbstractOptional2Action> OPTIONAL2_OPTION_KEY;
+
+        static {
+            OptionDefinition[] definitions = buildDefinitions(MyParser1.class);
+
+            HELP_OPTION_KEY = new OptionKey<OptionHelp1, MyParser1, AbstractHelp1Action>("help", OptionHelp1.class, AbstractHelp1Action.class, "", definitions[0]);
+            MANDATORY1_OPTION_KEY = new OptionKey<Option, MyParser1, AbstractMandatory1Action>("mandatory1", Option.class, AbstractMandatory1Action.class, "", definitions[1]);
+            MANDATORY2_OPTION_KEY = new OptionKey<Option, MyParser1, AbstractMandatory2Action>("mandatory2", Option.class, AbstractMandatory2Action.class, "", definitions[2]);
+            OPTIONAL1_OPTION_KEY = new OptionKey<Option, MyParser1, AbstractOptional1Action>("optional1", Option.class, AbstractOptional1Action.class, "", definitions[3]);
+            OPTIONAL2_OPTION_KEY = new OptionKey<Option, MyParser1, AbstractOptional2Action>("optional2", Option.class, AbstractOptional2Action.class, "", definitions[4]);
+        }
+
+        protected static void buildDefinitions(OptionDefinitionBuilder builder) {
+            builder.beginBuilder(5);
+            builder.beginOption(0);
+            builder.endOption("help", 0, 1, "--help", "-h");
+
+            builder.beginOption(1);
+            builder.beginGroup(1);
+            builder.addArgument(constant, STRING, "mconstant1", 1, 1);
+            builder.endGroup(0);
+            builder.endOption("mandatory1", 1, 1, "--mandatory1", "-m1");
+
+            builder.beginOption(1);
+            builder.beginGroup(1);
+            builder.addArgument(constant, STRING, "mconstant2", 0, 1);
+            builder.endGroup(-1);
+            builder.endOption("mandatory2", 1, 1, "--mandatory2", "-m2");
+
+            builder.beginOption(1);
+            builder.beginGroup(1);
+            builder.addArgument(constant, STRING, "oconstant1", 1, 1);
+            builder.endGroup(0);
+            builder.endOption("optional1", 0, 1, "--optional1", "-o1");
+
+            builder.beginOption(1);
+            builder.beginGroup(1);
+            builder.addArgument(constant, STRING, "oconstant2", 0, 1);
+            builder.endGroup(-1);
+            builder.endOption("optional2", 0, 1, "--optional2", "-o2");
+        }
+    }
+
+    protected static OptionParser parser;
+
+    public void testArgumentsBeforeFirstOption() throws Exception {
+        initParser(MyParser.class);
+        parser.doParse("first", "help");
+        ParserUtilForTest.assertError(parser, 0, 0, 2);
+
+        parser.doParse("first", "--help");
+        ParserUtilForTest.assertError(parser, 1, 0, 1);
+
+        parser.doParse("first", "second", "-h");
+        ParserUtilForTest.assertError(parser, 1, 0, 2);
+    }
+
+    public void testMandatoryGroup() throws Exception {
+        initParser(MyParser1.class);
+        MyParser1 parser = (MyParser1) ParserTest.parser;
+
+        parser.doParse("--mandatory1");
+        ParserUtilForTest.assertError(parser, 0, 3, 0);
+
+        parser.doParse("-m1", "-m2");
+        ParserUtilForTest.assertError(parser, 1, 2, 0);
+
+        parser.doParse("-m1", "-m2", "--mandatory2");
+        ParserUtilForTest.assertError(parser, 1, 3, 0);
+
+        parser.doParse("-m1", "mconstant1");
+        ParserUtilForTest.assertError(parser, 1, 1, 0);
+
+        parser.doParse("-m1", "mconstant1", "mconstant1", "-m2");
+        ParserUtilForTest.assertError(parser, 1, 2, 0);
+
+        parser.doParse("-m1", "mconstant1", "-m2", "-h");
+        ParserUtilForTest.assertError(parser, 3, 0, 0);
+
+        OptionHelp1[] ops = parser.getOptions(MyParser1.HELP_OPTION_KEY);
+        assertEquals(1, ops.length);
+        OptionHelp1 op = parser.getOption(MyParser1.HELP_OPTION_KEY);
+        assertNotNull(op);
+        parser.doAllActions();
+        assertEquals(3, counter);
+    }
+
+    public void testTooMuchOptionFound() throws Exception {
+        initParser(MyParser.class);
+
+        parser.doParse("-h", "--help");
+        ParserUtilForTest.assertError(parser, 1, 1, 0);
+
+        parser.doParse("--help", "--help");
+        ParserUtilForTest.assertError(parser, 1, 1, 0);
+
+        parser.doParse("-h", "-h");
+        ParserUtilForTest.assertError(parser, 1, 1, 0);
+        parser.doParse("-h", "-h", "-h");
+        ParserUtilForTest.assertError(parser, 1, 2, 0);
+    }
+
+    protected void initParser(Class<? extends OptionParser> parserClass) throws IllegalAccessException, InstantiationException {
+        try {
+            parser = parserClass.newInstance();
+            parser.registerActions(getClass());
+            StringWriter writer = new StringWriter();
+            parser.printUsage(writer, getName());
+            log.info('\n' + writer.toString());
+            writer.close();
+        } catch (IOException e) {
+            fail(e.getMessage());
+        }
+    }
+
+}