From e32debe1df7d0a837e30cd937fb7a18fc5cfa203 Mon Sep 17 00:00:00 2001 From: Robert Godfrey Date: Thu, 24 Apr 2008 17:49:03 +0000 Subject: QPID-832 : Fix eol-style git-svn-id: https://svn.apache.org/repos/asf/incubator/qpid/trunk@651325 13f79535-47bb-0310-9956-ffa450edef68 --- .../apache/qpid/util/CommandLineParserTest.java | 1108 ++++++++++---------- 1 file changed, 554 insertions(+), 554 deletions(-) (limited to 'qpid/java/common/src/test') diff --git a/qpid/java/common/src/test/java/org/apache/qpid/util/CommandLineParserTest.java b/qpid/java/common/src/test/java/org/apache/qpid/util/CommandLineParserTest.java index 66fb3252df..942901f1c0 100644 --- a/qpid/java/common/src/test/java/org/apache/qpid/util/CommandLineParserTest.java +++ b/qpid/java/common/src/test/java/org/apache/qpid/util/CommandLineParserTest.java @@ -1,554 +1,554 @@ -/* - * - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, - * software distributed under the License is distributed on an - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY - * KIND, either express or implied. See the License for the - * specific language governing permissions and limitations - * under the License. - * - */ - -package org.apache.qpid.util; - -import junit.framework.*; - -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import java.util.Properties; - -/** - * Unit tests the {@link CommandLineParser} class. - * - *

- *
CRC Card
Responsibilities Collaborations - *
Check that parsing a single flag works ok. - *
Check that parsing multiple flags condensed together works ok. - *
Check that parsing an option with a space between it and its argument works ok. - *
Check that parsing an option with no space between it and its argument works ok. - *
Check that parsing an option with specific argument format works ok. - *
Check that parsing an option with specific argument format fails on bad argument. - *
Check that parsing a flag condensed together with an option fails. - *
Check that parsing a free argument works ok. - *
Check that parsing a free argument with specific format works ok. - *
Check that parsing a free argument with specific format fails on bad argument. - *
Check that parsing a mandatory option works ok. - *
Check that parsing a mandatory free argument works ok. - *
Check that parsing a mandatory option fails when no option is set. - *
Check that parsing a mandatory free argument fails when no argument is specified. - *
Check that parsing an unknown option works when unknowns not errors. - *
Check that parsing an unknown flag fails when unknowns are to be reported as errors. - *
Check that parsing an unknown option fails when unknowns are to be reported as errors. - *
Check that get errors returns a string on errors. - *
Check that get errors returns an empty string on no errors. - *
Check that get usage returns a string. - *
Check that get options in force returns an empty string before parsing. - *
Check that get options in force return a non-empty string after parsing. - *
- */ -public class CommandLineParserTest extends TestCase -{ - private static final Logger log = LoggerFactory.getLogger(CommandLineParserTest.class); - - public CommandLineParserTest(String name) - { - super(name); - } - - /** - * Compile all the tests for the default test implementation of a traversable state into a test suite. - */ - public static Test suite() - { - // Build a new test suite - TestSuite suite = new TestSuite("CommandLineParser Tests"); - - // Add all the tests defined in this class (using the default constructor) - suite.addTestSuite(CommandLineParserTest.class); - - return suite; - } - - /** Check that get errors returns an empty string on no errors. */ - public void testGetErrorsReturnsEmptyStringOnNoErrors() throws Exception - { - // Create a command line parser for some flags and options. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" }, - { "t3", "Test Option 3.", "test", "true" }, - { "t4", "Test Option 4.", "test", null, "^test$" } - }); - - // Do some legal parsing. - parser.parseCommandLine(new String[] { "-t1", "-t2test", "-t3test", "-t4test" }); - - // Check that the get errors message returns an empty string. - assertTrue("The errors method did not return an empty string.", "".equals(parser.getErrors())); - } - - /** Check that get errors returns a string on errors. */ - public void testGetErrorsReturnsStringOnErrors() throws Exception - { - // Create a command line parser for some flags and options. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" }, - { "t3", "Test Option 3.", "test", "true" }, - { "t4", "Test Option 4.", "test", null, "^test$" } - }); - - try - { - // Do some illegal parsing. - parser.parseCommandLine(new String[] { "-t1", "-t1t2test", "-t4fail" }); - } - catch (IllegalArgumentException e) - { } - - // Check that the get errors message returns a string. - assertTrue("The errors method returned an empty string.", - !((parser.getErrors() == null) || "".equals(parser.getErrors()))); - - } - - /** Check that get options in force returns an empty string before parsing. */ - public void testGetOptionsInForceReturnsEmptyStringBeforeParsing() throws Exception - { - // Create a command line parser for some flags and options. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" }, - { "t3", "Test Option 3.", "test", "true" }, - { "t4", "Test Option 4.", "test", null, "^test$" } - }); - - // Check that the options in force method returns an empty string. - assertTrue("The options in force method did not return an empty string.", "".equals(parser.getOptionsInForce())); - } - - /** Check that get options in force return a non-empty string after parsing. */ - public void testGetOptionsInForceReturnsNonEmptyStringAfterParsing() throws Exception - { - // Create a command line parser for some flags and options. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" }, - { "t3", "Test Option 3.", "test", "true" }, - { "t4", "Test Option 4.", "test", null, "^test$" } - }); - - // Do some parsing. - parser.parseCommandLine(new String[] { "-t1", "-t2test", "-t3test", "-t4test" }); - - // Check that the options in force method returns a string. - assertTrue("The options in force method did not return a non empty string.", - !((parser.getOptionsInForce() == null) || "".equals(parser.getOptionsInForce()))); - } - - /** Check that get usage returns a string. */ - public void testGetUsageReturnsString() throws Exception - { - // Create a command line parser for some flags and options. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" }, - { "t3", "Test Option 3.", "test", "true" }, - { "t4", "Test Option 4.", "test", null, "^test$" } - }); - - // Check that the usage method returns a string. - assertTrue("The usage method did not return a non empty string.", - !((parser.getUsage() == null) || "".equals(parser.getUsage()))); - } - - /** Check that parsing multiple flags condensed together works ok. */ - public void testParseCondensedFlagsOk() throws Exception - { - // Create a command line parser for multiple flags. - CommandLineParser parser = - new CommandLineParser( - new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Flag 2." }, - { "t3", "Test Flag 3." } - }); - - // Parse a command line with the flags set and condensed together. - Properties testProps = parser.parseCommandLine(new String[] { "-t1t2t3" }); - - // Check that the flags were set in the parsed properties. - assertTrue("The t1 flag was not \"true\", it was: " + testProps.get("t1"), "true".equals(testProps.get("t1"))); - assertTrue("The t2 flag was not \"true\", it was: " + testProps.get("t2"), "true".equals(testProps.get("t2"))); - assertTrue("The t3 flag was not \"true\", it was: " + testProps.get("t3"), "true".equals(testProps.get("t3"))); - } - - /** Check that parsing a flag condensed together with an option fails. */ - public void testParseFlagCondensedWithOptionFails() throws Exception - { - // Create a command line parser for a flag and an option. - CommandLineParser parser = - new CommandLineParser(new String[][] - { - { "t1", "Test Flag 1." }, - { "t2", "Test Option 2.", "test" } - }); - - // Check that the parser reports an error. - boolean testPassed = false; - - try - { - // Parse a command line with the flag and option condensed together. - Properties testProps = parser.parseCommandLine(new String[] { "-t1t2" }); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - assertTrue("IllegalArgumentException not thrown when a flag and option are condensed together.", testPassed); - } - - /** Check that parsing a free argument with specific format fails on bad argument. */ - public void testParseFormattedFreeArgumentFailsBadArgument() throws Exception - { - // Create a command line parser for a formatted free argument. - CommandLineParser parser = - new CommandLineParser(new String[][] - { - { "1", "Test Free Argument.", "test", null, "^test$" } - }); - - // Check that the parser signals an error for a badly formatted argument. - boolean testPassed = false; - - try - { - // Parse a command line with this option set incorrectly. - Properties testProps = parser.parseCommandLine(new String[] { "fail" }); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - assertTrue("IllegalArgumentException not thrown when a badly formatted argument was set.", testPassed); - } - - /** Check that parsing a free argument with specific format works ok. */ - public void testParseFormattedFreeArgumentOk() throws Exception - { - // Create a command line parser for a formatted free argument. - CommandLineParser parser = - new CommandLineParser(new String[][] - { - { "1", "Test Free Argument.", "test", null, "^test$" } - }); - - // Parse a command line with this argument set correctly. - Properties testProps = parser.parseCommandLine(new String[] { "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), - "test".equals(testProps.get("1"))); - } - - /** Check that parsing an option with specific argument format fails on bad argument. */ - public void testParseFormattedOptionArgumentFailsBadArgument() throws Exception - { - // Create a command line parser for a formatted option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test", null, "^test$" } - }); - - // Check that the parser signals an error for a badly formatted argument. - boolean testPassed = false; - - try - { - // Parse a command line with this option set incorrectly. - Properties testProps = parser.parseCommandLine(new String[] { "-t", "fail" }); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - assertTrue("IllegalArgumentException not thrown when a badly formatted argument was set.", testPassed); - } - - /** Check that parsing an option with specific argument format works ok. */ - public void testParseFormattedOptionArgumentOk() throws Exception - { - // Create a command line parser for a formatted option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test", null, "^test$" } - }); - - // Parse a command line with this option set correctly. - Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), - "test".equals(testProps.get("t"))); - } - - /** Check that parsing a free argument works ok. */ - public void testParseFreeArgumentOk() throws Exception - { - // Create a command line parser for a free argument. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "1", "Test Free Argument.", "test" } - }); - - // Parse a command line with this argument set. - Properties testProps = parser.parseCommandLine(new String[] { "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), - "test".equals(testProps.get("1"))); - } - - /** Check that parsing a mandatory option works ok. */ - public void testParseMandatoryOptionOk() throws Exception - { - // Create a command line parser for a mandatory option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test", "true" } - }); - - // Parse a command line with this option set correctly. - Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), - "test".equals(testProps.get("t"))); - } - - /** Check that parsing a mandatory free argument works ok. */ - public void testParseMandatoryFreeArgumentOk() throws Exception - { - // Create a command line parser for a mandatory free argument. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "1", "Test Option.", "test", "true" } - }); - - // Parse a command line with this argument set. - Properties testProps = parser.parseCommandLine(new String[] { "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), - "test".equals(testProps.get("1"))); - } - - /** Check that parsing a mandatory free argument fails when no argument is specified. */ - public void testParseManadatoryFreeArgumentFailsNoArgument() throws Exception - { - // Create a command line parser for a mandatory free argument. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "1", "Test Option.", "test", "true" } - }); - - // Check that parsing fails when this mandatory free argument is missing. - boolean testPassed = false; - - try - { - // Parse a command line with this free argument not set. - Properties testProps = parser.parseCommandLine(new String[] {}); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("IllegalArgumentException not thrown for a missing mandatory option.", testPassed); - } - - /** Check that parsing a mandatory option fails when no option is set. */ - public void testParseMandatoryFailsNoOption() throws Exception - { - // Create a command line parser for a mandatory option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test", "true" } - }); - - // Check that parsing fails when this mandatory option is missing. - boolean testPassed = false; - - try - { - // Parse a command line with this option not set. - Properties testProps = parser.parseCommandLine(new String[] {}); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("IllegalArgumentException not thrown for a missing mandatory option.", testPassed); - } - - /** Check that parsing an option with no space between it and its argument works ok. */ - public void testParseOptionWithNoSpaceOk() throws Exception - { - // Create a command line parser for an option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test" } - }); - - // Parse a command line with this option set with no space. - Properties testProps = parser.parseCommandLine(new String[] { "-ttest" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), - "test".equals(testProps.get("t"))); - } - - /** Check that parsing an option with a space between it and its argument works ok. */ - public void testParseOptionWithSpaceOk() throws Exception - { - // Create a command line parser for an option. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Option.", "test" } - }); - - // Parse a command line with this option set with a space. - Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); - - // Check that the resultant properties contains the correctly parsed option. - assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), - "test".equals(testProps.get("t"))); - } - - /** Check that parsing a single flag works ok. */ - public void testParseSingleFlagOk() throws Exception - { - // Create a command line parser for a single flag. - CommandLineParser parser = new CommandLineParser(new String[][] - { - { "t", "Test Flag." } - }); - - // Parse a command line with the single flag set. - Properties testProps = parser.parseCommandLine(new String[] { "-t" }); - - // Check that the flag is set in the parsed properties. - assertTrue("The t flag was not \"true\", it was: " + testProps.get("t"), "true".equals(testProps.get("t"))); - - // Reset the parser. - parser.reset(); - - // Parse a command line with the single flag not set. - testProps = parser.parseCommandLine(new String[] {}); - - // Check that the flag is cleared in the parsed properties. - assertTrue("The t flag was not \"false\", it was: " + testProps.get("t"), "false".equals(testProps.get("t"))); - } - - /** Check that parsing an unknown option works when unknowns not errors. */ - public void testParseUnknownOptionOk() throws Exception - { - // Create a command line parser for no flags or options - CommandLineParser parser = new CommandLineParser(new String[][] {}); - - // Check that parsing does not fail on an unknown flag. - try - { - parser.parseCommandLine(new String[] { "-t" }); - } - catch (IllegalArgumentException e) - { - fail("The parser threw an IllegalArgumentException on an unknown flag when errors on unkowns is off."); - } - } - - /** Check that parsing an unknown flag fails when unknowns are to be reported as errors. */ - public void testParseUnknownFlagFailsWhenUnknownsAreErrors() throws Exception - { - // Create a command line parser for no flags or options - CommandLineParser parser = new CommandLineParser(new String[][] {}); - - // Turn on fail on unknowns mode. - parser.setErrorsOnUnknowns(true); - - // Check that parsing fails on an unknown flag. - boolean testPassed = false; - - try - { - parser.parseCommandLine(new String[] { "-t" }); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - assertTrue("IllegalArgumentException not thrown for an unknown flag when errors on unknowns mode is on.", - testPassed); - } - - /** Check that parsing an unknown option fails when unknowns are to be reported as errors. */ - public void testParseUnknownOptionFailsWhenUnknownsAreErrors() throws Exception - { - // Create a command line parser for no flags or options - CommandLineParser parser = new CommandLineParser(new String[][] {}); - - // Turn on fail on unknowns mode. - parser.setErrorsOnUnknowns(true); - - // Check that parsing fails on an unknown flag. - boolean testPassed = false; - - try - { - parser.parseCommandLine(new String[] { "-t", "test" }); - } - catch (IllegalArgumentException e) - { - testPassed = true; - } - - assertTrue("IllegalArgumentException not thrown for an unknown option when errors on unknowns mode is on.", - testPassed); - } -} +/* + * + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.qpid.util; + +import junit.framework.*; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.util.Properties; + +/** + * Unit tests the {@link CommandLineParser} class. + * + *

+ *
CRC Card
Responsibilities Collaborations + *
Check that parsing a single flag works ok. + *
Check that parsing multiple flags condensed together works ok. + *
Check that parsing an option with a space between it and its argument works ok. + *
Check that parsing an option with no space between it and its argument works ok. + *
Check that parsing an option with specific argument format works ok. + *
Check that parsing an option with specific argument format fails on bad argument. + *
Check that parsing a flag condensed together with an option fails. + *
Check that parsing a free argument works ok. + *
Check that parsing a free argument with specific format works ok. + *
Check that parsing a free argument with specific format fails on bad argument. + *
Check that parsing a mandatory option works ok. + *
Check that parsing a mandatory free argument works ok. + *
Check that parsing a mandatory option fails when no option is set. + *
Check that parsing a mandatory free argument fails when no argument is specified. + *
Check that parsing an unknown option works when unknowns not errors. + *
Check that parsing an unknown flag fails when unknowns are to be reported as errors. + *
Check that parsing an unknown option fails when unknowns are to be reported as errors. + *
Check that get errors returns a string on errors. + *
Check that get errors returns an empty string on no errors. + *
Check that get usage returns a string. + *
Check that get options in force returns an empty string before parsing. + *
Check that get options in force return a non-empty string after parsing. + *
+ */ +public class CommandLineParserTest extends TestCase +{ + private static final Logger log = LoggerFactory.getLogger(CommandLineParserTest.class); + + public CommandLineParserTest(String name) + { + super(name); + } + + /** + * Compile all the tests for the default test implementation of a traversable state into a test suite. + */ + public static Test suite() + { + // Build a new test suite + TestSuite suite = new TestSuite("CommandLineParser Tests"); + + // Add all the tests defined in this class (using the default constructor) + suite.addTestSuite(CommandLineParserTest.class); + + return suite; + } + + /** Check that get errors returns an empty string on no errors. */ + public void testGetErrorsReturnsEmptyStringOnNoErrors() throws Exception + { + // Create a command line parser for some flags and options. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" }, + { "t3", "Test Option 3.", "test", "true" }, + { "t4", "Test Option 4.", "test", null, "^test$" } + }); + + // Do some legal parsing. + parser.parseCommandLine(new String[] { "-t1", "-t2test", "-t3test", "-t4test" }); + + // Check that the get errors message returns an empty string. + assertTrue("The errors method did not return an empty string.", "".equals(parser.getErrors())); + } + + /** Check that get errors returns a string on errors. */ + public void testGetErrorsReturnsStringOnErrors() throws Exception + { + // Create a command line parser for some flags and options. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" }, + { "t3", "Test Option 3.", "test", "true" }, + { "t4", "Test Option 4.", "test", null, "^test$" } + }); + + try + { + // Do some illegal parsing. + parser.parseCommandLine(new String[] { "-t1", "-t1t2test", "-t4fail" }); + } + catch (IllegalArgumentException e) + { } + + // Check that the get errors message returns a string. + assertTrue("The errors method returned an empty string.", + !((parser.getErrors() == null) || "".equals(parser.getErrors()))); + + } + + /** Check that get options in force returns an empty string before parsing. */ + public void testGetOptionsInForceReturnsEmptyStringBeforeParsing() throws Exception + { + // Create a command line parser for some flags and options. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" }, + { "t3", "Test Option 3.", "test", "true" }, + { "t4", "Test Option 4.", "test", null, "^test$" } + }); + + // Check that the options in force method returns an empty string. + assertTrue("The options in force method did not return an empty string.", "".equals(parser.getOptionsInForce())); + } + + /** Check that get options in force return a non-empty string after parsing. */ + public void testGetOptionsInForceReturnsNonEmptyStringAfterParsing() throws Exception + { + // Create a command line parser for some flags and options. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" }, + { "t3", "Test Option 3.", "test", "true" }, + { "t4", "Test Option 4.", "test", null, "^test$" } + }); + + // Do some parsing. + parser.parseCommandLine(new String[] { "-t1", "-t2test", "-t3test", "-t4test" }); + + // Check that the options in force method returns a string. + assertTrue("The options in force method did not return a non empty string.", + !((parser.getOptionsInForce() == null) || "".equals(parser.getOptionsInForce()))); + } + + /** Check that get usage returns a string. */ + public void testGetUsageReturnsString() throws Exception + { + // Create a command line parser for some flags and options. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" }, + { "t3", "Test Option 3.", "test", "true" }, + { "t4", "Test Option 4.", "test", null, "^test$" } + }); + + // Check that the usage method returns a string. + assertTrue("The usage method did not return a non empty string.", + !((parser.getUsage() == null) || "".equals(parser.getUsage()))); + } + + /** Check that parsing multiple flags condensed together works ok. */ + public void testParseCondensedFlagsOk() throws Exception + { + // Create a command line parser for multiple flags. + CommandLineParser parser = + new CommandLineParser( + new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Flag 2." }, + { "t3", "Test Flag 3." } + }); + + // Parse a command line with the flags set and condensed together. + Properties testProps = parser.parseCommandLine(new String[] { "-t1t2t3" }); + + // Check that the flags were set in the parsed properties. + assertTrue("The t1 flag was not \"true\", it was: " + testProps.get("t1"), "true".equals(testProps.get("t1"))); + assertTrue("The t2 flag was not \"true\", it was: " + testProps.get("t2"), "true".equals(testProps.get("t2"))); + assertTrue("The t3 flag was not \"true\", it was: " + testProps.get("t3"), "true".equals(testProps.get("t3"))); + } + + /** Check that parsing a flag condensed together with an option fails. */ + public void testParseFlagCondensedWithOptionFails() throws Exception + { + // Create a command line parser for a flag and an option. + CommandLineParser parser = + new CommandLineParser(new String[][] + { + { "t1", "Test Flag 1." }, + { "t2", "Test Option 2.", "test" } + }); + + // Check that the parser reports an error. + boolean testPassed = false; + + try + { + // Parse a command line with the flag and option condensed together. + Properties testProps = parser.parseCommandLine(new String[] { "-t1t2" }); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + assertTrue("IllegalArgumentException not thrown when a flag and option are condensed together.", testPassed); + } + + /** Check that parsing a free argument with specific format fails on bad argument. */ + public void testParseFormattedFreeArgumentFailsBadArgument() throws Exception + { + // Create a command line parser for a formatted free argument. + CommandLineParser parser = + new CommandLineParser(new String[][] + { + { "1", "Test Free Argument.", "test", null, "^test$" } + }); + + // Check that the parser signals an error for a badly formatted argument. + boolean testPassed = false; + + try + { + // Parse a command line with this option set incorrectly. + Properties testProps = parser.parseCommandLine(new String[] { "fail" }); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + assertTrue("IllegalArgumentException not thrown when a badly formatted argument was set.", testPassed); + } + + /** Check that parsing a free argument with specific format works ok. */ + public void testParseFormattedFreeArgumentOk() throws Exception + { + // Create a command line parser for a formatted free argument. + CommandLineParser parser = + new CommandLineParser(new String[][] + { + { "1", "Test Free Argument.", "test", null, "^test$" } + }); + + // Parse a command line with this argument set correctly. + Properties testProps = parser.parseCommandLine(new String[] { "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), + "test".equals(testProps.get("1"))); + } + + /** Check that parsing an option with specific argument format fails on bad argument. */ + public void testParseFormattedOptionArgumentFailsBadArgument() throws Exception + { + // Create a command line parser for a formatted option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test", null, "^test$" } + }); + + // Check that the parser signals an error for a badly formatted argument. + boolean testPassed = false; + + try + { + // Parse a command line with this option set incorrectly. + Properties testProps = parser.parseCommandLine(new String[] { "-t", "fail" }); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + assertTrue("IllegalArgumentException not thrown when a badly formatted argument was set.", testPassed); + } + + /** Check that parsing an option with specific argument format works ok. */ + public void testParseFormattedOptionArgumentOk() throws Exception + { + // Create a command line parser for a formatted option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test", null, "^test$" } + }); + + // Parse a command line with this option set correctly. + Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), + "test".equals(testProps.get("t"))); + } + + /** Check that parsing a free argument works ok. */ + public void testParseFreeArgumentOk() throws Exception + { + // Create a command line parser for a free argument. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "1", "Test Free Argument.", "test" } + }); + + // Parse a command line with this argument set. + Properties testProps = parser.parseCommandLine(new String[] { "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), + "test".equals(testProps.get("1"))); + } + + /** Check that parsing a mandatory option works ok. */ + public void testParseMandatoryOptionOk() throws Exception + { + // Create a command line parser for a mandatory option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test", "true" } + }); + + // Parse a command line with this option set correctly. + Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), + "test".equals(testProps.get("t"))); + } + + /** Check that parsing a mandatory free argument works ok. */ + public void testParseMandatoryFreeArgumentOk() throws Exception + { + // Create a command line parser for a mandatory free argument. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "1", "Test Option.", "test", "true" } + }); + + // Parse a command line with this argument set. + Properties testProps = parser.parseCommandLine(new String[] { "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The first free argument was not equal to \"test\" but was: " + testProps.get("1"), + "test".equals(testProps.get("1"))); + } + + /** Check that parsing a mandatory free argument fails when no argument is specified. */ + public void testParseManadatoryFreeArgumentFailsNoArgument() throws Exception + { + // Create a command line parser for a mandatory free argument. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "1", "Test Option.", "test", "true" } + }); + + // Check that parsing fails when this mandatory free argument is missing. + boolean testPassed = false; + + try + { + // Parse a command line with this free argument not set. + Properties testProps = parser.parseCommandLine(new String[] {}); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("IllegalArgumentException not thrown for a missing mandatory option.", testPassed); + } + + /** Check that parsing a mandatory option fails when no option is set. */ + public void testParseMandatoryFailsNoOption() throws Exception + { + // Create a command line parser for a mandatory option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test", "true" } + }); + + // Check that parsing fails when this mandatory option is missing. + boolean testPassed = false; + + try + { + // Parse a command line with this option not set. + Properties testProps = parser.parseCommandLine(new String[] {}); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("IllegalArgumentException not thrown for a missing mandatory option.", testPassed); + } + + /** Check that parsing an option with no space between it and its argument works ok. */ + public void testParseOptionWithNoSpaceOk() throws Exception + { + // Create a command line parser for an option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test" } + }); + + // Parse a command line with this option set with no space. + Properties testProps = parser.parseCommandLine(new String[] { "-ttest" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), + "test".equals(testProps.get("t"))); + } + + /** Check that parsing an option with a space between it and its argument works ok. */ + public void testParseOptionWithSpaceOk() throws Exception + { + // Create a command line parser for an option. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Option.", "test" } + }); + + // Parse a command line with this option set with a space. + Properties testProps = parser.parseCommandLine(new String[] { "-t", "test" }); + + // Check that the resultant properties contains the correctly parsed option. + assertTrue("The test option was not equal to \"test\" but was: " + testProps.get("t"), + "test".equals(testProps.get("t"))); + } + + /** Check that parsing a single flag works ok. */ + public void testParseSingleFlagOk() throws Exception + { + // Create a command line parser for a single flag. + CommandLineParser parser = new CommandLineParser(new String[][] + { + { "t", "Test Flag." } + }); + + // Parse a command line with the single flag set. + Properties testProps = parser.parseCommandLine(new String[] { "-t" }); + + // Check that the flag is set in the parsed properties. + assertTrue("The t flag was not \"true\", it was: " + testProps.get("t"), "true".equals(testProps.get("t"))); + + // Reset the parser. + parser.reset(); + + // Parse a command line with the single flag not set. + testProps = parser.parseCommandLine(new String[] {}); + + // Check that the flag is cleared in the parsed properties. + assertTrue("The t flag was not \"false\", it was: " + testProps.get("t"), "false".equals(testProps.get("t"))); + } + + /** Check that parsing an unknown option works when unknowns not errors. */ + public void testParseUnknownOptionOk() throws Exception + { + // Create a command line parser for no flags or options + CommandLineParser parser = new CommandLineParser(new String[][] {}); + + // Check that parsing does not fail on an unknown flag. + try + { + parser.parseCommandLine(new String[] { "-t" }); + } + catch (IllegalArgumentException e) + { + fail("The parser threw an IllegalArgumentException on an unknown flag when errors on unkowns is off."); + } + } + + /** Check that parsing an unknown flag fails when unknowns are to be reported as errors. */ + public void testParseUnknownFlagFailsWhenUnknownsAreErrors() throws Exception + { + // Create a command line parser for no flags or options + CommandLineParser parser = new CommandLineParser(new String[][] {}); + + // Turn on fail on unknowns mode. + parser.setErrorsOnUnknowns(true); + + // Check that parsing fails on an unknown flag. + boolean testPassed = false; + + try + { + parser.parseCommandLine(new String[] { "-t" }); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + assertTrue("IllegalArgumentException not thrown for an unknown flag when errors on unknowns mode is on.", + testPassed); + } + + /** Check that parsing an unknown option fails when unknowns are to be reported as errors. */ + public void testParseUnknownOptionFailsWhenUnknownsAreErrors() throws Exception + { + // Create a command line parser for no flags or options + CommandLineParser parser = new CommandLineParser(new String[][] {}); + + // Turn on fail on unknowns mode. + parser.setErrorsOnUnknowns(true); + + // Check that parsing fails on an unknown flag. + boolean testPassed = false; + + try + { + parser.parseCommandLine(new String[] { "-t", "test" }); + } + catch (IllegalArgumentException e) + { + testPassed = true; + } + + assertTrue("IllegalArgumentException not thrown for an unknown option when errors on unknowns mode is on.", + testPassed); + } +} -- cgit v1.2.1