Index: lutinutil/src/test/org/codelutin/util/ParserUtil.java diff -u lutinutil/src/test/org/codelutin/util/ParserUtil.java:1.1 lutinutil/src/test/org/codelutin/util/ParserUtil.java:1.2 --- lutinutil/src/test/org/codelutin/util/ParserUtil.java:1.1 Sun Dec 2 05:19:01 2007 +++ lutinutil/src/test/org/codelutin/util/ParserUtil.java Wed Dec 5 03:04:49 2007 @@ -14,10 +14,9 @@ import junit.framework.Assert; import org.codelutin.i18n.I18n; +import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA; +import org.codelutin.util.OptionParserAnnotationHelper.GroupArgumentA; 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; @@ -46,7 +45,7 @@ } } - protected static void assertParserEquals(OptionParserA expected, OptionParserA found) { + protected static void assertParserEquals(OptionParserAnnotationHelper.ApplicationA expected, OptionParserAnnotationHelper.ApplicationA found) { Assert.assertNotNull(found); int length = expected.options().length; assertEquals(length, found.options().length); @@ -71,8 +70,8 @@ } } - protected static void assertGroupEquals(OptionGroupArgumentA expected, - OptionGroupArgumentA found) { + protected static void assertGroupEquals(OptionParserAnnotationHelper.GroupArgumentA expected, + GroupArgumentA found) { assertEquals(expected.min(), found.min()); assertEquals(expected.max(), found.max()); assertEquals(expected.pos(), found.pos()); @@ -85,8 +84,8 @@ } } - protected static void assertArgumentEquals(OptionArgumentA expected, - OptionArgumentA found) { + protected static void assertArgumentEquals(OptionParserAnnotationHelper.ArgumentA expected, + ArgumentA found) { assertEquals(expected.min(), found.min()); assertEquals(expected.max(), found.max()); assertEquals(expected.key(), found.key()); @@ -101,32 +100,31 @@ writer.flush(); writer.close(); assertEquals(nbErrors != 0, parser.hasFailed()); - assertEquals(nbOptions, parser.safeContexts.length); - assertEquals(nbErrors, parser.errors.size()); + assertEquals(nbOptions, parser.options.length); + assertEquals(nbErrors, parser.errors.length); } + - - protected static File initFileMock(String optionName, String... defs) throws IOException { + protected 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 += 2) { String definition = defs[i]; String description = defs[i + 1]; - builder.append(optionName); + builder.append(key); if (i > 0) { builder.append(i); } - builder.append(".definition=").append(definition).append("\n").append(optionName); + builder.append(".").append(type).append(".definition=").append(definition).append("\n").append(key); if (i > 0) { builder.append(i); } - builder.append(".description=").append(description).append("\n"); + builder.append(".").append(type).append(".description=").append(description).append("\n"); } String content = builder.toString(); - return initFileMock0(PROPERTIES_FILE_PATH, optionName + ".properties", content); + 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()) { Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java diff -u lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.2 lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.3 --- lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java:1.2 Sun Dec 2 05:19:03 2007 +++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserTest.java Wed Dec 5 03:04:49 2007 @@ -26,21 +26,14 @@ */ public class OptionDefinitionParserTest extends TestCase { - - @Override - protected void setUp() throws Exception { - super.setUp(); - ParserUtil.initI18n(); - } - OptionDefinitionParser parser; File file; String optionName; public void testNoOptions() throws Exception { - file = ParserUtil.initFileMock("","testNoOptions.properties", ""); + file = ParserUtil.initFileMock("", "option", "testNoOptions.properties", ""); parser = OptionDefinitionParser.doParse(properties, file); - assertEquals(0, parser.toDefinitions().length); + assertEquals(null, parser.toAnnotation()); } public void testOneOption() throws Exception { @@ -113,37 +106,36 @@ assertEquals(14, parser.getDefinitions()[0].getGroups().length);*/ } - public void testOneOptionArgumentCardinalite() throws Exception { optionName = "testArgumentConstantCardinalite00005"; - file = ParserUtil.initFileMock(optionName, "-testArgumentConstantCardinalite00005 ", "ok with 1 mandatory constant argument cardinalite : 1,1"); + file = ParserUtil.initFileMock(optionName, "option", "-testArgumentConstantCardinalite00005 ", "ok with 1 mandatory constant argument cardinalite : 1,1"); parser = OptionDefinitionParser.doParse(properties, file); ParserUtil.assertError(parser, 1, 0); optionName = "testArgumentConstantCardinalite00015"; - file = ParserUtil.initFileMock(optionName, "-testArgumentConstantCardinalite00015 [constant]", "ok with 1 optional constant argument cardinalite : 0,1"); + file = ParserUtil.initFileMock(optionName, "option", "-testArgumentConstantCardinalite00015 [constant]", "ok with 1 optional constant argument cardinalite : 0,1"); parser = OptionDefinitionParser.doParse(properties, file); ParserUtil.assertError(parser, 1, 0); optionName = "testArgumentValuedCardinalite00003"; - file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00003 ", "ok with a 1,+ mandatory valued argument cardinalite : +"); + file = ParserUtil.initFileMock(optionName, "option", "-testArgumentValuedCardinalite00003 ", "ok with a 1,+ mandatory valued argument cardinalite : +"); parser = OptionDefinitionParser.doParse(properties, file); ParserUtil.assertError(parser, 1, 0); optionName = "testArgumentValuedCardinalite00004"; - file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00004 ", "ok with a 0,+ mandatory valued argument cardinalite : 1,-1"); + file = ParserUtil.initFileMock(optionName, "option", "-testArgumentValuedCardinalite00004 ", "ok with a 0,+ mandatory valued argument cardinalite : 1,-1"); parser = OptionDefinitionParser.doParse(properties, file); ParserUtil.assertError(parser, 1, 0); optionName = "testArgumentValuedCardinalite00010"; - file = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00010 [string:string{0,5}]", "ok with 0,* optional valued argument cardinalite 0,5"); + file = ParserUtil.initFileMock(optionName, "option", "-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 = ParserUtil.initFileMock(optionName, "-testArgumentValuedCardinalite00011 [string:string*]", "ok with a 0,* optional valued argument cardinalite *"); + file = ParserUtil.initFileMock(optionName, "option", "-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/OptionDefinitionParserWalkerTest.java diff -u lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java:1.2 lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java:1.3 --- lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java:1.2 Sun Dec 2 07:16:39 2007 +++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserWalkerTest.java Wed Dec 5 03:04:49 2007 @@ -14,34 +14,34 @@ import junit.framework.TestCase; import static org.codelutin.util.OptionDefinitionParser.TypeSource.properties; +import org.codelutin.util.OptionParserAnnotationHelper.ApplicationA; +import org.codelutin.util.OptionParserAnnotationHelper.ArgumentA; +import org.codelutin.util.OptionParserAnnotationHelper.GroupArgumentA; 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( +@ApplicationA( options = {@OptionA( key = "option", alias = {"--keyOne", "-1"}, min = 1, max = 2, description = "--keyOne|-1 {1,2} ", - groups = @OptionGroupArgumentA(min = 1, max = 1, pos = 0, + groups = @GroupArgumentA(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)} + @ArgumentA(key = "arguOne", type = OptionArgumentType.valued, valueType = OptionArgumentValueType._boolean, min = 123, max = 143), + @ArgumentA(key = "arguTwo", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._class)} ) ), @OptionA( key = "option2", alias = {"--keyTwo", "-2"}, min = 1, max = 2, description = "--keyTwo|-2 {1,2} ", - groups = @OptionGroupArgumentA(min = 1, max = 1, pos = 0, + groups = @GroupArgumentA(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)} + @ArgumentA(key = "arguOne2", type = OptionArgumentType.valued, valueType = OptionArgumentValueType._boolean, min = 123, max = 143), + @ArgumentA(key = "arguTwo2", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._class), + @ArgumentA(key = "arguTwo3", type = OptionArgumentType.namedAndValued, valueType = OptionArgumentValueType._file)} ) )} ) @@ -64,30 +64,30 @@ File file; public void testToAnnotationWalker() throws Exception { - OptionParserA excepted = getClass().getAnnotation(OptionParserA.class); + ApplicationA excepted = getClass().getAnnotation(ApplicationA.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()); + file = ParserUtil.initFileMock("option", "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 = OptionParserUtil.ToAnnotationWalker.getInstance().run(parser.safeContexts); + ApplicationA found = OptionParserUtil.ToAnnotationWalker.getInstance().run(parser.options, parser.arguments, Option.class); ParserUtil.assertParserEquals(excepted, found); - OptionParserA found2 = parser.toAnnotation(); + ApplicationA found2 = parser.toAnnotation(); ParserUtil.assertParserEquals(excepted, found2); } public void testToDefinitionWalker() throws Exception { - OptionParserA excepted = getClass().getAnnotation(OptionParserA.class); + ApplicationA excepted = getClass().getAnnotation(ApplicationA.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()); + file = ParserUtil.initFileMock("option", "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 = OptionParserUtil.ToDefinitionWalker.getInstance().run(parser.safeContexts); - //OptionDefinition[] found2 = parser.toDefinitions(); + //OptionDefinition[] found = OptionParserUtil.ToDefinitionWalker.getInstance().run(parser.options); + //OptionDefinition[] found2 = parser.toDefinition(); //TODO Make a assertEquals between OptionDefinition and OptionA //ParserUtil.assertParserEquals(excepted, found); } Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadArgumentTest.java diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadArgumentTest.java:1.1 --- /dev/null Wed Dec 5 03:04:54 2007 +++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadArgumentTest.java Wed Dec 5 03:04:49 2007 @@ -0,0 +1,124 @@ +/** + * ##% 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 java.io.File; +import java.io.IOException; + +/** + * OptionDefinitionParser Tester. + * + * @author chemit + * @version 1.0 + * @since 
11/18/2007
+ */ +@SuppressWarnings({"DuplicateStringLiteralInspection", "HardCodedStringLiteral"}) +public class OptionDefinitionParserBadArgumentTest extends TestCase { + + @Override + protected void setUp() throws Exception { + super.setUp(); + ParserUtil.initI18n(); + } + + OptionDefinitionParser parser; + File file; + String key; + + private static final String TYPE = "argument"; + + public void testOneArgumentNoDescription() throws Exception { + initAndParse("testNoDescription", ""); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("", "no definition!"); + ParserUtil.assertError(parser, 0, 1); + } + + + public void testOneArgumentBadCardinalite() throws Exception { + initAndParse("testBadCardinalite0 {-1,1}", "with a bad min card -1 "); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("testBadCardinalite0 {-1,-1}", "with a bad min card -1 "); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("testBadCardinalite1 {1,-2}", "with a bad max card -2 "); + ParserUtil.assertError(parser, 0, 2); + + initAndParse("testBadCardinalite2 {1,0}", "with a bad max card 0 < min 1 "); + ParserUtil.assertError(parser, 0, 2); + + initAndParse("testBadCardinalite3 {5,3}", "with a bad max < min "); + ParserUtil.assertError(parser, 0, 1); + } + + public void testOneArgumentBadSyntax() throws Exception { + + //TODO Make test of cardinalite on StringUtil where algo is... + + initAndParse("constant{{0,0}", "with a too much {"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant{-{1,0}", "with a too much {"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant{-{1,0}", "with a too much {"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant}{0,-2}", "with a too much }"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant[{0,0}", "with a too much ["); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant{-1,0}[", "with a too much ["); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant{-1,0}]]]", "with a too much ]"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("]constant{0,1}", "with a too much ]"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant!{0,1}", "bad caracter found"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant!{0,1}", "bad caracter found"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("constant", "duplicated key", "constant", "duplicated key2"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("string:string", "mismatch type", "file:newFile", "mismatch type 2"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("string:strin", "unknow value type", "file:newFile", "ok"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("string=string", "duplicated key", "string:newFile", "duplicated key"); + ParserUtil.assertError(parser, 0, 1); + + } + + private void initAndParse(String... defs) throws IOException { + key = getName() + System.currentTimeMillis(); + file = ParserUtil.initFileMock(key, TYPE, defs); + parser = OptionDefinitionParser.doParse(properties, file); + } + + +} \ No newline at end of file Index: lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadOptionTest.java diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadOptionTest.java:1.1 --- /dev/null Wed Dec 5 03:04:55 2007 +++ lutinutil/src/test/org/codelutin/util/OptionDefinitionParserBadOptionTest.java Wed Dec 5 03:04:49 2007 @@ -0,0 +1,213 @@ +/** + * ##% 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 java.io.File; +import java.io.IOException; + +/** + * OptionDefinitionParser Tester. + * + * @author chemit + * @version 1.0 + * @since 
11/18/2007
+ */ +@SuppressWarnings({"DuplicateStringLiteralInspection", "HardCodedStringLiteral"}) +public class OptionDefinitionParserBadOptionTest extends TestCase { + + private String TYPE="option"; + + @Override + protected void setUp() throws Exception { + super.setUp(); + ParserUtil.initI18n(); + } + + OptionDefinitionParser parser; + File file; + String key; + + public void testOneOptionNoDescription() throws Exception { + + initAndParse("-testNoDescription", ""); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("", "no definition!"); + ParserUtil.assertError(parser, 0, 1); + + } + + public void testOneOptionBadAlias() throws Exception { + + initAndParse("testOneOption", "with no alias (unvalid one)"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testOneOptionsBad00|t", "bad alias (no - at prefix)"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testOneOptionsBad00|-t|-t2|-t3|-t4", "too much alias"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testOneOptionsBad00|-t|-t2|t3|-t4|-t5|t55", "too much alias and bad one"); + ParserUtil.assertError(parser, 0, 3); + + initAndParse("-testOneOptionsBad000 {0,2}", "ok with no args ", "-testOneOptionsBad000 {0,4}", "duplicated alias -testOneOptionsBad000"); + ParserUtil.assertError(parser, 1, 1); + + initAndParse("-testOneOptionsBad000|-t0", "ok with no args ", "-testOneOptionsBad001|-t0", "duplicated alias -t0"); + ParserUtil.assertError(parser, 1, 1); + } + + public void testOneOptionBadCardinalite() throws Exception { + + initAndParse("-testBadCardinalite0 {-1,1}", "with a bad min card -1 "); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testBadCardinalite1 {1,-2}", "with a bad max card -2 "); + ParserUtil.assertError(parser, 0, 2); + + initAndParse("-testBadCardinalite2 {1,0}", "with a bad max card 0 < min 1 "); + ParserUtil.assertError(parser, 0, 2); + + initAndParse("-testBadCardinalite3 {5,3}", "with a bad max < min "); + ParserUtil.assertError(parser, 0, 1); + + } + + public void testOneOptionBadConstantArgumentCardinalite() throws Exception { + key = "testBadArgumentConstantCardinalite0"; + initAndParse("-testBadArgumentConstantCardinalite0 ", "with a max cardinalite of an argument to zero"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00"; + initAndParse("-testBadArgumentConstantCardinalite00 ", "with a min cardinalite of an argument < 0"); + + ParserUtil.assertError(parser, 0, 2); + + key = "testBadArgumentConstantCardinalite000"; + initAndParse("-testBadArgumentConstantCardinalite000 ", "with a max cardinalite of an argument < -1"); + + ParserUtil.assertError(parser, 0, 2); + + key = "testBadArgumentConstantCardinalite0000"; + initAndParse("-testBadArgumentConstantCardinalite0000 ", "with a max cardinalite of an argument < min"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00000"; + initAndParse("-testBadArgumentConstantCardinalite00000 ", "with a none mandatory constant argument cardinalite 0,1"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00001"; + initAndParse("-testBadArgumentConstantCardinalite00001 ", "with a none mandatory constant argument cardinalite *"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00002"; + initAndParse("-testBadArgumentConstantCardinalite00002 ", "with a none 1,1 mandatory constant argument cardinalite : 1,2"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00003"; + initAndParse("-testBadArgumentConstantCardinalite00003 ", "with a none 1,1 mandatory constant argument cardinalite : +"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00004"; + initAndParse("-testBadArgumentConstantCardinalite00004 ", "with a none 1,1 mandatory constant argument cardinalite : 1,-1"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00010"; + initAndParse("-testBadArgumentConstantCardinalite00010 [constant{0,5}]", "with a none 0,1 optional constant argument cardinalite 0,5"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00011"; + initAndParse("-testBadArgumentConstantCardinalite00011 [constant*]", "with a none 0,1 optional constant argument cardinalite *"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00012"; + initAndParse("-testBadArgumentConstantCardinalite00012 [constant{1,2}]", "with a none 0,1 optional constant argument cardinalite : 1,2"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00013"; + initAndParse("-testBadArgumentConstantCardinalite00013 [constant+]", "with a none 0,1 optional constant argument cardinalite : +"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentConstantCardinalite00014"; + initAndParse("-testBadArgumentConstantCardinalite00014 [constant{1,-1}]", "with a none 0,1 optional constant argument cardinalite : 1,-1"); + + ParserUtil.assertError(parser, 0, 1); + } + + public void testOneOptionBadValuedArgumentCardinalite() throws Exception { + key = "testBadArgumentValuedCardinalite0"; + initAndParse("-testBadArgumentValuedCardinalite0 ", "with a max valued cardinalite of an argument to zero"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentValuedCardinalite00"; + initAndParse("-testBadArgumentValuedCardinalite00 ", "with a min valued cardinalite of an argument < 0"); + + ParserUtil.assertError(parser, 0, 2); + + key = "testBadArgumentValuedCardinalite000"; + initAndParse("-testBadArgumentValuedCardinalit000 ", "with a none 1,+ mandatory valued argument cardinalite cardinalite 0,-1"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentValuedCardinalite0000"; + initAndParse("-testBadArgumentValuedCardinalite0000 ", "with a max valued cardinalite of an argument < min"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentValuedCardinalite00000"; + initAndParse("-testBadArgumentValuedCardinalite00000 ", "with a none 1,+ mandatory valued argument cardinalite 0,1"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentValuedCardinalite00001"; + initAndParse("-testBadArgumentValuedCardinalite00001 ", "with a none 1,+ mandatory valued argument cardinalite *"); + + ParserUtil.assertError(parser, 0, 1); + + key = "testBadArgumentValuedCardinalite00002"; + initAndParse("-testBadArgumentValuedCardinalite00002 ", "with a none 1,+ mandatory valued argument cardinalite : 1,2"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testArgumentValuedCardinalite00012 [string:string{1,2}]", "with a none 0,* optional valued argument cardinalite : 1,2"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testBadArgumentValuedCardinalite00013 [string:string+]", "with a none 0,* optional valued argument cardinalite : +"); + ParserUtil.assertError(parser, 0, 1); + + initAndParse("-testBadArgumentValuedCardinalite00014 [string:string{1,-1}]", "with a none 0,* optional valued argument cardinalite : 1,-1"); + ParserUtil.assertError(parser, 0, 1); + + } + + private void initAndParse(String... defs) throws IOException { + key = getName() + System.currentTimeMillis(); + file = ParserUtil.initFileMock(key, TYPE, defs); + parser = OptionDefinitionParser.doParse(properties, file); + } +} \ No newline at end of file Index: lutinutil/src/test/org/codelutin/util/OptionParserTest.java diff -u /dev/null lutinutil/src/test/org/codelutin/util/OptionParserTest.java:1.1 --- /dev/null Wed Dec 5 03:04:56 2007 +++ lutinutil/src/test/org/codelutin/util/OptionParserTest.java Wed Dec 5 03:04:49 2007 @@ -0,0 +1,384 @@ +package org.codelutin.util; + +import junit.framework.TestCase; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.codelutin.util.OptionParserAnnotationHelper.*; + +import java.io.File; +import java.io.StringWriter; + +/** + * OptionParser Tester. + * + * @author chemit + * @version 1.0 + * @since 
11/14/2007
+ */ +public class OptionParserTest extends TestCase { + + static private Log log = LogFactory.getLog(OptionParserTest.class); + + private static final String PROJECT_NAME = OptionParserTest.class.getSimpleName(); + private static final String HERE = new File("").getAbsolutePath(); + private static final String OUT_PATH = new File(HERE, "target/gen/classes").getAbsolutePath(); + private static final String PARSER_NAME = "org.codelutin.util.OptionParserTest"; + private static final String PROPERTIES_FILE_PATH = HERE + "/src/test/testOptions.properties"; + +// private OptionParser parser; +// private Option option0, option1, option2, option3, option4; +// private OptionContextOld context0, context1, context2, context3, context4; + + protected void setUp() throws Exception { + super.setUp(); + ParserUtil.initI18n(); + } + + public void testParserFromAnnotation() throws Exception { + + @ApplicationA(options = @OptionA(key = "help", alias = {"--help", "-h"}, description = "affiche l'aide")) + class MyParser extends OptionParser { + } + + MyParser parser = new MyParser(); + + StringWriter writer = new StringWriter(); + parser.printUsage(writer,"mon parseur"); + System.out.println(writer); + writer.close(); + + } +// public void testDetectOptions() throws Exception { +// List result; +// List expected; +// String[] args; +// expected = new ArrayList(); +// +// args = new String[]{"-0", "-1", "-2", "-3", "-4"}; +// mockParser(); +// expected.add(context0); +// expected.add(context1); +// expected.add(context2); +// expected.add(context3); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// // aucun argument laissé de côté +// assertSame(expected, result, 0); +// +// args = new String[]{"-4", "-3", "-2", "-1", "-0",}; +// expected.clear(); +// mockParser(); +// expected.add(context4); +// expected.add(context3); +// expected.add(context2); +// expected.add(context1); +// expected.add(context0); +// +// result = parser.detectOptions(args); +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertSame(expected, result, 0); +// +// args = new String[]{"-0", "-2", "-3", "-4"}; +// expected.clear(); +// mockParser(); +// expected.add(context0); +// expected.add(context2); +// expected.add(context3); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// // aucun argument laissé de côté +// assertSame(expected, result, 0); +// +// args = new String[]{"-0", "-2", "-33", "-4"}; +// expected.clear(); +// mockParser(); +// expected.add(context0); +// expected.add(context2); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// assertSame(expected, result, 1); +// // 1 argument laissé de côté (-33) +// assertEquals("-33", parser.arguments.get(0)); +// +// args = new String[]{"-0", "-0", "-2", "-33", "-4"}; +// expected.clear(); +// mockParser(); +// expected.add(context0); +// expected.add(context0); +// expected.add(context2); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// assertSame(expected, result, 1); +// // 1 argument laissé de côté (-33) +// assertEquals("-33", parser.arguments.get(0)); +// +// args = new String[]{"-0", "arg0", "-1", "-2", "-33", "-4"}; +// expected.clear(); +// mockParser(); +// context0.args = new String[1]; +// context0.args[0] = "arg0"; +// expected.add(context0); +// expected.add(context1); +// expected.add(context2); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// assertSame(expected, result, 1); +// // 1 argument laissé de côté (-33) +// assertEquals("-33", parser.arguments.get(0)); +// +// args = new String[]{"-0", "arg0", "-1", "-1", "-2", "-33", "-4", "arg4", "arg44",}; +// expected.clear(); +// mockParser(); +// expected.add(context0); +// expected.add(context1); +// expected.add(context1); +// expected.add(context2); +// context4.args = new String[2]; +// context4.args[0] = "arg4"; +// context4.args[1] = "arg44"; +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// assertSame(expected, result, 1); +// // 1 argument laissé de côté (-33) +// assertEquals("-33", parser.arguments.get(0)); +// +// args = new String[]{"-33", "-0", "arg0", "--option1", "-1", "-2", "-4", "arg4", "arg44", "-34",}; +// expected.clear(); +// mockParser(); +// expected.add(context0); +// expected.add(context1); +// expected.add(context1); +// expected.add(context2); +// expected.add(context4); +// +// result = parser.detectOptions(args); +// +// assertSame(expected, result, 2); +// // 1 argument laissé de côté (-33) +// assertEquals("-33", parser.arguments.get(0)); +// assertEquals("-34", parser.arguments.get(1)); +// } + +// public void testParse() throws Exception { +// Option[] result; +// //Option[] expected; +// String[] args; +// +// +// args = new String[]{"-0", "constant", "help"}; +// //mockParser2(); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse(args); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(2, result[0].getArguments().length); +// assertEquals("constant", result[0].getArguments()[0]); +// assertEquals("help", result[0].getArguments()[1]); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// try { +// parser.parse("-0", "help"); +// // miss a mandatory argument +// fail(); +// } catch (OptionParserException e) { +// assertTrue(true); +// } +// +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key=0"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(1, result[0].getArguments().length); +// assertEquals((long) 0, result[0].getArguments()[0]); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key2=0"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(1, result[0].getArguments().length); +// assertEquals((double) 0, result[0].getArguments()[0]); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// try { +// parser.parse("-0", "key2=a"); +// fail(); +// } catch (OptionParserException e) { +// assertTrue(true); +// } +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// try { +// parser.parse("-0", "key=0", "key2=a"); +// // key2 is unused +// fail(); +// } catch (OptionParserException e) { +// assertTrue(true); +// } +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// try { +// parser.parse("-0", "key=0", "help", "help"); +// // key2 is unused +// fail(); +// } catch (OptionParserException e) { +// assertTrue(true); +// } +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key2=0", "key3=fr.ifremer.isisfish.IsisFishOption", "help"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(3, result[0].getArguments().length); +// assertEquals((double) 0, result[0].getArguments()[0]); +// assertEquals(fr.ifremer.isisfish.IsisFishOption.class, result[0].getArguments()[1]); +// assertEquals("help", result[0].getArguments()[2]); +// +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help|file:file]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key2=0", "key3=fr.ifremer.isisfish.IsisFishOption", "help", "/tmp"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(4, result[0].getArguments().length); +// assertEquals((double) 0, result[0].getArguments()[0]); +// assertEquals(fr.ifremer.isisfish.IsisFishOption.class, result[0].getArguments()[1]); +// assertEquals("help", result[0].getArguments()[2]); +// assertEquals(new java.io.File("/tmp"), result[0].getArguments()[3]); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help|file:newfile]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key2=0", "key3=fr.ifremer.isisfish.IsisFishOption", "help", "/tmp2"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(4, result[0].getArguments().length); +// assertEquals((double) 0, result[0].getArguments()[0]); +// assertEquals(fr.ifremer.isisfish.IsisFishOption.class, result[0].getArguments()[1]); +// assertEquals("help", result[0].getArguments()[2]); +// assertEquals(new java.io.File("/tmp2"), result[0].getArguments()[3]); +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help|file:newfile|str:string]", 1, 1); +// +// try { +// parser.addSon(option0); +// // can't use :string and :newfile in same group +// fail(); +// } catch (Exception e) { +// assertTrue(true); +// } +// +// parser = new OptionParser("testParse"); +// option0 = new Option("option0", "", "-0|--option0 [help|file:file|str:string]", 1, 1); +// parser.addSon(option0); +// +// result = parser.parse("-0", "key2=0", "key3=fr.ifremer.isisfish.IsisFishOption", "help", "/tmp", "str"); +// +// // aucun argument laissé de côté +// assertEquals(0, parser.arguments.size()); +// assertEquals(1, result.length); +// assertEquals(5, result[0].getArguments().length); +// assertEquals((double) 0, result[0].getArguments()[0]); +// assertEquals(fr.ifremer.isisfish.IsisFishOption.class, result[0].getArguments()[1]); +// assertEquals("help", result[0].getArguments()[2]); +// assertEquals(new java.io.File("/tmp"), result[0].getArguments()[3]); +// assertEquals("str", result[0].getArguments()[4]); +// +// } + +// +// private void mockOptions() { +// option0 = new Option("option0", "", "-0|--option0 ", 0, 0); +// option1 = new Option("option1", "", "-1|--option1 ", 0, 0); +// option2 = new Option("option2", "", "-2|--option2 ", 0, 0); +// option3 = new Option("option3", "", "-3|--option3 ", 0, 0); +// option4 = new Option("option4", "", "-4|--option4 ", 0, 0); +// } +// +// private void mockContexts() { +// context0 = new OptionParser.OptionContextOld(option0, new String[0]); +// context1 = new OptionParser.OptionContextOld(option1, new String[0]); +// context2 = new OptionParser.OptionContextOld(option2, new String[0]); +// context3 = new OptionParser.OptionContextOld(option3, new String[0]); +// context4 = new OptionParser.OptionContextOld(option4, new String[0]); +// } + +// private void mockParser() { +// +// parser = new OptionParser("testDetectOptions"); +// +// parser.addSon(option0); +// parser.addSon(option1); +// parser.addSon(option2); +// parser.addSon(option3); +// parser.addSon(option4); +// } + +// private void assertSame(List expected, List result, int nbArgumentsLeft) { +// +//// assertEquals(nbArgumentsLeft, parser.arguments.size()); +// assertEquals(expected.size(), result.size()); +// for (int i = 0; i < result.size(); i++) { +// OptionParser.OptionContextOld context = result.get(i); +// OptionParser.OptionContextOld expectedContext = expected.get(i); +// assertTrue(Arrays.equals(expectedContext.args, context.args)); +// assertTrue(Arrays.equals(expectedContext.option.def.getAlias(), +// context.option.def.getAlias())); +// } +// } + + +}