From 8828b89ef7587c4b6f8bc62af6da31dc86893f4b Mon Sep 17 00:00:00 2001 From: Niklas Date: Sat, 7 Dec 2024 12:33:37 +0100 Subject: [PATCH 1/2] reduce the side effect programming on args & make args be passed to .parse() instead of the ArgsParser instance directly --- src/ArgsParser/ArgsParser.java | 51 ++++---- src/test/TestAddParameterMethods.java | 168 +++++++++++++------------- src/test/TestArgsExceptions.java | 113 ++++++++--------- 3 files changed, 165 insertions(+), 167 deletions(-) diff --git a/src/ArgsParser/ArgsParser.java b/src/ArgsParser/ArgsParser.java index cd87bde..6002335 100644 --- a/src/ArgsParser/ArgsParser.java +++ b/src/ArgsParser/ArgsParser.java @@ -44,7 +44,7 @@ *
  • {@link ArgsParser#addCommand(String, String, String)}
    • * * - *
  • After all parameters are added, the {@link ArgsParser#parse()} method has to be called! (this is mandatory!)
    • + *
  • After all parameters are added, the {@link ArgsParser#parse(String[] args)} method has to be called! (this is mandatory!)
    • *
  • Then the arguments can be accessed by using {@link Parameter#getArgument()} on the specific Parameter variable * which will return the parsed argument of that parameter as the specified type or for commands by using the * {@link Command#isProvided()} at the respective command instance to check rather the command was provided or not
    • @@ -54,7 +54,6 @@ */ public class ArgsParser { - private final String[] args; private final Map> parameterMap = new HashMap<>(); private final Map commandMap = new HashMap<>(); private final Set> mandatoryParameters = new HashSet<>(); @@ -64,17 +63,12 @@ public class ArgsParser { protected boolean parseArgsWasCalled = false; private int longestFlagSize = 0; private int longestShortFlag = 0; - private final int argsLength; /** * Constructor - * @param args arguments given to the program * @throws IllegalArgumentException if args is null */ - public ArgsParser(String[] args) throws IllegalArgumentException { - if (args == null) throw new IllegalArgumentException("Args cannot be null!"); - this.args = args; - this.argsLength = args.length; + public ArgsParser() throws IllegalArgumentException { } /** @@ -629,11 +623,12 @@ public Command addCommand(String fullCommandName, String shortCommandName, Strin * * If an ArgsException is thrown, its message is printed to the * standard output and the application exits with a status code of 1. + * @throws IllegalArgumentException if args is null */ - public void parse() { + public void parse(String[] args) throws IllegalArgumentException { try { - parseUnchecked(); + parseUnchecked(args); } catch (CalledForHelpNotification help) { System.out.println(help.getMessage()); @@ -662,20 +657,22 @@ public void parse() { * @throws IllegalStateException if the .parse() method is called more than once. * @throws FlagAlreadyProvidedArgsException if a flag is provided more than once. * @throws HelpAtWrongPositionArgsException if the help argument is positioned incorrectly. + * @throws IllegalArgumentException if args is null */ - public void parseUnchecked() throws NoArgumentsProvidedArgsException, UnknownFlagArgsException, + public void parseUnchecked(String[] args) throws NoArgumentsProvidedArgsException, UnknownFlagArgsException, TooManyArgumentsArgsException, MissingArgArgsException, MandatoryArgNotProvidedArgsException, CalledForHelpNotification, InvalidArgTypeArgsException, IllegalStateException, - FlagAlreadyProvidedArgsException, HelpAtWrongPositionArgsException { + FlagAlreadyProvidedArgsException, HelpAtWrongPositionArgsException, IllegalArgumentException { + if (args == null) throw new IllegalArgumentException("Args cannot be null!"); if(parseArgsWasCalled) throw new IllegalStateException(".parse() was already called!"); parseArgsWasCalled = true; - checkIfAnyArgumentsProvided(); - if (argsLength > 0) { - checkForHelpCall(); - Set> givenParameters = parseArguments(); + checkIfAnyArgumentsProvided(args); + if (args.length > 0) { + checkForHelpCall(args); + Set> givenParameters = parseArguments(args); checkMandatoryArguments(givenParameters); } } @@ -686,8 +683,8 @@ public void parseUnchecked() throws NoArgumentsProvidedArgsException, UnknownFla * to run without any arguments as long as no mandatory parameters were defined on this ArgsParser. * @throws NoArgumentsProvidedArgsException if no arguments were provided in args */ - private void checkIfAnyArgumentsProvided() throws NoArgumentsProvidedArgsException { - if (argsLength == 0 & !mandatoryParameters.isEmpty()) { + private void checkIfAnyArgumentsProvided(String[] args) throws NoArgumentsProvidedArgsException { + if (args.length == 0 & !mandatoryParameters.isEmpty()) { throw new NoArgumentsProvidedArgsException(); } } @@ -698,9 +695,9 @@ private void checkIfAnyArgumentsProvided() throws NoArgumentsProvidedArgsExcepti * @throws UnknownFlagArgsException if an unknown flag was provided in args * @throws CalledForHelpNotification if --help or -h was called */ - private void checkForHelpCall() throws UnknownFlagArgsException, CalledForHelpNotification { - boolean oneArgProvided = argsLength == 1; - boolean twoArgsProvided = argsLength == 2; + private void checkForHelpCall(String[] args) throws UnknownFlagArgsException, CalledForHelpNotification { + boolean oneArgProvided = args.length == 1; + boolean twoArgsProvided = args.length == 2; boolean firstArgumentIsParameter = parameterMap.get(args[0]) != null; boolean firstArgumentIsCommand = commandMap.get(args[0]) != null; @@ -741,21 +738,21 @@ private void checkForHelpCall() throws UnknownFlagArgsException, CalledForHelpNo * @throws FlagAlreadyProvidedArgsException If a flag is provided more than once. * @throws HelpAtWrongPositionArgsException If the help flag is not in the correct position. */ - private Set> parseArguments() throws UnknownFlagArgsException, TooManyArgumentsArgsException, + private Set> parseArguments(String[] args) throws UnknownFlagArgsException, TooManyArgumentsArgsException, MissingArgArgsException, InvalidArgTypeArgsException, FlagAlreadyProvidedArgsException, HelpAtWrongPositionArgsException { Set> givenParameters = new HashSet<>(); //check if the first argument provided is actually a flag or command - if (argsLength > 0 && parameterMap.get(args[0]) == null && commandMap.get(args[0]) == null && + if (args.length > 0 && parameterMap.get(args[0]) == null && commandMap.get(args[0]) == null && !(args[0].equals("--help") || args[0].equals("-h"))) { throw new UnknownFlagArgsException(args[0], parameterMap.keySet(), commandMap.keySet(), true); } Parameter currentParameter = null; boolean longFlagUsed = false; - for (int i = 0; i < argsLength; i++) { + for (int i = 0; i < args.length; i++) { boolean currentPositionIsFlag = args[i].startsWith("-"); if (currentPositionIsFlag) { @@ -764,14 +761,14 @@ private Set> parseArguments() throws UnknownFlagArgsException, TooM } boolean currentPositionIsCommand = commandMap.get(args[i]) != null; boolean flagExists = parameterMap.get(args[i]) != null; - boolean isLastEntry = i == argsLength - 1; + boolean isLastEntry = i == args.length - 1; boolean currentParameterNotNull = currentParameter != null; boolean argumentSet = currentParameterNotNull && currentParameter.hasArgument(); boolean lastPositionWasFlag = i >= 1 && args[i - 1].startsWith("-"); boolean flagAlreadyProvided = false; if (flagExists) flagAlreadyProvided = givenParameters.contains(currentParameter); boolean isHelpCall = ("--help".equals(args[i]) || "-h".equals(args[i])); - boolean helpCallInWrongPosition = isHelpCall && (i > 1 || (i == 0 && argsLength == 2)); + boolean helpCallInWrongPosition = isHelpCall && (i > 1 || (i == 0 && args.length == 2)); if (helpCallInWrongPosition) { throw new HelpAtWrongPositionArgsException(); @@ -803,7 +800,7 @@ private Set> parseArguments() throws UnknownFlagArgsException, TooM if (isArrayParam) { // we "collect" all following arguments after an array parameter in a StringBuilder StringBuilder arguments = new StringBuilder(); arguments.append(args[i]).append("==="); // every entry in the array gets seperated by === - while(i + 1 < argsLength && !args[i + 1].startsWith("-") && !commandMap.containsKey(args[i + 1])) { // loop through all arguments + while(i + 1 < args.length && !args[i + 1].startsWith("-") && !commandMap.containsKey(args[i + 1])) { // loop through all arguments arguments.append(args[++i]).append("==="); } currentParameter.setArgument(arguments.toString()); diff --git a/src/test/TestAddParameterMethods.java b/src/test/TestAddParameterMethods.java index 69bbd53..0fd2c1e 100644 --- a/src/test/TestAddParameterMethods.java +++ b/src/test/TestAddParameterMethods.java @@ -14,9 +14,9 @@ public class TestAddParameterMethods { @Test public void testAddMandatoryStringParameter() { String[] args = {"--String", "this is a string"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter str = parser.addMandatoryStringParameter("String", "s", "desc"); - parser.parse(); + parser.parse(args); assertEquals("this is a string", str.getArgument()); } @@ -24,9 +24,9 @@ public void testAddMandatoryStringParameter() { @Test public void testAddOptionalStringParameter() { String[] args = {"--String", "this is a string"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter str = parser.addOptionalStringParameter("String", "s", "desc"); - parser.parse(); + parser.parse(args); assertEquals("this is a string", str.getArgument()); } @@ -34,9 +34,9 @@ public void testAddOptionalStringParameter() { @Test public void testAddDefaultStringParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter deafult = parser.addDefaultStringParameter("DefaultString", "df", "desc", "this is the default"); - parser.parse(); + parser.parse(args); assertEquals("this is the default", deafult.getArgument()); } @@ -44,9 +44,9 @@ public void testAddDefaultStringParameterWithoutArgument() { @Test public void testAddDefaultStringParameterWithArgument() { String[] args = {"--DefaultString", "this is a string"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultParam = parser.addDefaultStringParameter("DefaultString", "df", "desc", "this is the default"); - parser.parse(); + parser.parse(args); assertEquals("this is a string", defaultParam.getArgument()); } @@ -54,9 +54,9 @@ public void testAddDefaultStringParameterWithArgument() { @Test public void testAddStringArrayParameter() { String[] args = {"--StringArray", "this is a string", "and this is another"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringArray = parser.addStringArrayParameter("StringArray", "strA", "desc", true); - parser.parse(); + parser.parse(args); assertArrayEquals(new String[]{"this is a string", "and this is another"}, stringArray.getArgument()); } @@ -64,9 +64,9 @@ public void testAddStringArrayParameter() { @Test public void testAddDefaultStringArrayParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultStringArray = parser.addDefaultStringArrayParameter("StringArray", "strA", "desc", new String[]{"this is the default", "and this is another"}); - parser.parse(); + parser.parse(args); assertArrayEquals(new String[]{"this is the default", "and this is another"}, defaultStringArray.getArgument()); } @@ -74,9 +74,9 @@ public void testAddDefaultStringArrayParameterWithoutArgument() { @Test public void testAddStringArrayParameterWithArgument() { String[] args = {"--StringArray", "this is a string", "and this is another"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultStringArray = parser.addDefaultStringArrayParameter("StringArray", "strA", "desc", new String[]{"this", "is", "default"}); - parser.parse(); + parser.parse(args); assertArrayEquals(new String[]{"this is a string", "and this is another"}, defaultStringArray.getArgument()); } @@ -87,9 +87,9 @@ public void testAddStringArrayParameterWithArgument() { @Test public void testAddMandatoryIntegerParameter() { String[] args = {"--Integer", "42"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter integerParam = parser.addMandatoryIntegerParameter("Integer", "i", "desc"); - parser.parse(); + parser.parse(args); assertEquals(42, integerParam.getArgument()); } @@ -97,9 +97,9 @@ public void testAddMandatoryIntegerParameter() { @Test public void testAddOptionalIntegerParameter() { String[] args = {"--Integer", "42"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter integerParam = parser.addOptionalIntegerParameter("Integer", "i", "desc"); - parser.parse(); + parser.parse(args); assertEquals(42, integerParam.getArgument()); } @@ -107,9 +107,9 @@ public void testAddOptionalIntegerParameter() { @Test public void testAddDefaultIntegerParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultInteger = parser.addDefaultIntegerParameter("DefaultInteger", "di", "desc", 10); - parser.parse(); + parser.parse(args); assertEquals(10, defaultInteger.getArgument()); } @@ -117,9 +117,9 @@ public void testAddDefaultIntegerParameterWithoutArgument() { @Test public void testAddDefaultIntegerParameterWithArgument() { String[] args = {"--DefaultInteger", "42"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultInteger = parser.addDefaultIntegerParameter("DefaultInteger", "di", "desc", 10); - parser.parse(); + parser.parse(args); assertEquals(42, defaultInteger.getArgument()); } @@ -127,9 +127,9 @@ public void testAddDefaultIntegerParameterWithArgument() { @Test public void testAddIntegerArrayParameter() { String[] args = {"--IntegerArray", "1", "2", "3"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter integerArray = parser.addIntegerArrayParameter("IntegerArray", "intA", "desc", true); - parser.parse(); + parser.parse(args); assertArrayEquals(new Integer[]{1, 2, 3}, integerArray.getArgument()); } @@ -137,9 +137,9 @@ public void testAddIntegerArrayParameter() { @Test public void testAddDefaultIntegerArrayParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultIntegerArray = parser.addDefaultIntegerArrayParameter("IntegerArray", "intA", "desc", new Integer[]{4, 5, 6}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Integer[]{4, 5, 6}, defaultIntegerArray.getArgument()); } @@ -147,9 +147,9 @@ public void testAddDefaultIntegerArrayParameterWithoutArgument() { @Test public void testAddIntegerArrayParameterWithArgument() { String[] args = {"--IntegerArray", "1", "2", "3"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter intArray = parser.addDefaultIntegerArrayParameter("IntegerArray", "intA", "desc", new Integer[]{4, 5, 6}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Integer[]{1, 2, 3}, intArray.getArgument()); } @@ -160,9 +160,9 @@ public void testAddIntegerArrayParameterWithArgument() { @Test public void testAddMandatoryDoubleParameter() { String[] args = {"--Double", "42.0"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter doubleParam = parser.addMandatoryDoubleParameter("Double", "d", "desc"); - parser.parse(); + parser.parse(args); assertEquals(42.0, doubleParam.getArgument()); } @@ -170,9 +170,9 @@ public void testAddMandatoryDoubleParameter() { @Test public void testAddOptionalDoubleParameter() { String[] args = {"--Double", "42.0"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter doubleParam = parser.addOptionalDoubleParameter("Double", "d", "desc"); - parser.parse(); + parser.parse(args); assertEquals(42.0, doubleParam.getArgument()); } @@ -180,9 +180,9 @@ public void testAddOptionalDoubleParameter() { @Test public void testAddDefaultDoubleParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultDouble = parser.addDefaultDoubleParameter("DefaultDouble", "dd", "desc", 10.0); - parser.parse(); + parser.parse(args); assertEquals(10.0, defaultDouble.getArgument()); } @@ -190,9 +190,9 @@ public void testAddDefaultDoubleParameterWithoutArgument() { @Test public void testAddDefaultDoubleParameterWithArgument() { String[] args = {"--DefaultDouble", "42.0"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultDouble = parser.addDefaultDoubleParameter("DefaultDouble", "dd", "desc", 10.0); - parser.parse(); + parser.parse(args); assertEquals(42.0, defaultDouble.getArgument()); } @@ -200,9 +200,9 @@ public void testAddDefaultDoubleParameterWithArgument() { @Test public void testAddDoubleArrayParameter() { String[] args = {"--DoubleArray", "1.1", "2.2", "3.3"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter doubleArray = parser.addDoubleArrayParameter("DoubleArray", "dblA", "desc", true); - parser.parse(); + parser.parse(args); assertArrayEquals(new Double[]{1.1, 2.2, 3.3}, doubleArray.getArgument()); } @@ -210,9 +210,9 @@ public void testAddDoubleArrayParameter() { @Test public void testAddDefaultDoubleArrayParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultDoubleArray = parser.addDefaultDoubleArrayParameter("DoubleArray", "dblA", "desc", new Double[]{4.4, 5.5, 6.6}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Double[]{4.4, 5.5, 6.6}, defaultDoubleArray.getArgument()); } @@ -220,9 +220,9 @@ public void testAddDefaultDoubleArrayParameterWithoutArgument() { @Test public void testAddDefaultDoubleArrayParameterWithArgument() { String[] args = {"--DoubleArray", "1.1", "2.2", "3.3"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultDoubleArray = parser.addDefaultDoubleArrayParameter("DoubleArray", "dblA", "desc", new Double[]{4.4, 5.5, 6.6}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Double[]{1.1, 2.2, 3.3}, defaultDoubleArray.getArgument()); } @@ -233,9 +233,9 @@ public void testAddDefaultDoubleArrayParameterWithArgument() { @Test public void testAddMandatoryBooleanParameter() { String[] args = {"--Boolean", "true"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter booleanParam = parser.addMandatoryBooleanParameter("Boolean", "b", "desc"); - parser.parse(); + parser.parse(args); assertTrue(booleanParam.getArgument()); } @@ -243,9 +243,9 @@ public void testAddMandatoryBooleanParameter() { @Test public void testAddOptionalBooleanParameter() { String[] args = {"--Boolean", "true"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter booleanParam = parser.addOptionalBooleanParameter("Boolean", "b", "desc"); - parser.parse(); + parser.parse(args); assertTrue(booleanParam.getArgument()); } @@ -253,9 +253,9 @@ public void testAddOptionalBooleanParameter() { @Test public void testAddDefaultBooleanParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultBoolean = parser.addDefaultBooleanParameter("DefaultBoolean", "db", "desc", true); - parser.parse(); + parser.parse(args); assertTrue(defaultBoolean.getArgument()); } @@ -263,9 +263,9 @@ public void testAddDefaultBooleanParameterWithoutArgument() { @Test public void testAddDefaultBooleanParameterWithArgument() { String[] args = {"--DefaultBoolean", "false"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultBoolean = parser.addDefaultBooleanParameter("DefaultBoolean", "db", "desc", true); - parser.parse(); + parser.parse(args); assertFalse(defaultBoolean.getArgument()); } @@ -273,9 +273,9 @@ public void testAddDefaultBooleanParameterWithArgument() { @Test public void testAddBooleanArrayParameter() { String[] args = {"--BooleanArray", "true", "false", "true"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter booleanArray = parser.addBooleanArrayParameter("BooleanArray", "boolA", "desc", true); - parser.parse(); + parser.parse(args); assertArrayEquals(new Boolean[]{true, false, true}, booleanArray.getArgument()); } @@ -283,9 +283,9 @@ public void testAddBooleanArrayParameter() { @Test public void testAddDefaultBooleanArrayParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultBooleanArray = parser.addDefaultBooleanArrayParameter("BooleanArray", "boolA", "desc", new Boolean[]{true, false, true}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Boolean[]{true, false, true}, defaultBooleanArray.getArgument()); } @@ -293,9 +293,9 @@ public void testAddDefaultBooleanArrayParameterWithoutArgument() { @Test public void testAddDefaultBooleanArrayParameterWithArgument() { String[] args = {"--BooleanArray", "false", "true", "false"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultBooleanArray = parser.addDefaultBooleanArrayParameter("BooleanArray", "boolA", "desc", new Boolean[]{true, false, true}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Boolean[]{false, true, false}, defaultBooleanArray.getArgument()); } @@ -307,9 +307,9 @@ public void testAddDefaultBooleanArrayParameterWithArgument() { @Test public void testAddMandatoryCharacterParameter() { String[] args = {"--Character", "a"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter characterParam = parser.addMandatoryCharacterParameter("Character", "c", "desc"); - parser.parse(); + parser.parse(args); assertEquals('a', characterParam.getArgument()); } @@ -317,9 +317,9 @@ public void testAddMandatoryCharacterParameter() { @Test public void testAddOptionalCharacterParameter() { String[] args = {"--Character", "a"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter characterParam = parser.addOptionalCharacterParameter("Character", "c", "desc"); - parser.parse(); + parser.parse(args); assertEquals('a', characterParam.getArgument()); } @@ -327,9 +327,9 @@ public void testAddOptionalCharacterParameter() { @Test public void testAddDefaultCharacterParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultCharacter = parser.addDefaultCharacterParameter("DefaultCharacter", "dc", "desc", 'z'); - parser.parse(); + parser.parse(args); assertEquals('z', defaultCharacter.getArgument()); } @@ -337,9 +337,9 @@ public void testAddDefaultCharacterParameterWithoutArgument() { @Test public void testAddDefaultCharacterParameterWithArgument() { String[] args = {"--DefaultCharacter", "x"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultCharacter = parser.addDefaultCharacterParameter("DefaultCharacter", "dc", "desc", 'z'); - parser.parse(); + parser.parse(args); assertEquals('x', defaultCharacter.getArgument()); } @@ -347,9 +347,9 @@ public void testAddDefaultCharacterParameterWithArgument() { @Test public void testAddCharacterArrayParameter() { String[] args = {"--CharacterArray", "a", "b", "c"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter characterArray = parser.addCharacterArrayParameter("CharacterArray", "charA", "desc", true); - parser.parse(); + parser.parse(args); assertArrayEquals(new Character[]{'a', 'b', 'c'}, characterArray.getArgument()); } @@ -357,9 +357,9 @@ public void testAddCharacterArrayParameter() { @Test public void testAddDefaultCharacterArrayParameterWithoutArgument() { String[] args = new String[0]; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultCharacterArray = parser.addDefaultCharacterArrayParameter("CharacterArray", "charA", "desc", new Character[]{'x', 'y', 'z'}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Character[]{'x', 'y', 'z'}, defaultCharacterArray.getArgument()); } @@ -367,9 +367,9 @@ public void testAddDefaultCharacterArrayParameterWithoutArgument() { @Test public void testAddDefaultCharacterArrayParameterWithArgument() { String[] args = {"--CharacterArray", "a", "b", "c"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter defaultCharacterArray = parser.addDefaultCharacterArrayParameter("CharacterArray", "charA", "desc", new Character[]{'x', 'y', 'z'}); - parser.parse(); + parser.parse(args); assertArrayEquals(new Character[]{'a', 'b', 'c'}, defaultCharacterArray.getArgument()); } @@ -381,9 +381,9 @@ public void testAddDefaultCharacterArrayParameterWithArgument() { @Test public void testCommand() { String[] args = {"command"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Command command = parser.addCommand("command", "c", ""); - parser.parse(); + parser.parse(args); assertTrue(command.isProvided()); } @@ -391,9 +391,9 @@ public void testCommand() { @Test public void testIndirectCommandCheck() { String[] args = {"command"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Command command = parser.addCommand("command", "c", ""); - parser.parse(); + parser.parse(args); assertTrue(parser.checkIfCommandIsProvided("command")); } @@ -406,7 +406,7 @@ public void testIndirectCommandCheck() { public void testCombinationOfMandatoryArguments() { String[] args = new String[]{"-s", "stringInput", "-sArr", "string", "array", "-i", "12", "-iArr", "1", "2", "-d", "12.3", "-dArr", "1.2", "2.3", "-b", "true", "-bArr", "true", "false", "-c", "a", "-cArr", "d", "c"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringParam = parser.addMandatoryStringParameter("String", "s", "desc"); Parameter stringArrayParam = parser.addStringArrayParameter("StringArray", "sArr", "", false); Parameter intParam = parser.addMandatoryIntegerParameter("Int", "i", "desc"); @@ -417,7 +417,7 @@ public void testCombinationOfMandatoryArguments() { Parameter booleanArrayParam = parser.addBooleanArrayParameter("BooleanArray", "bArr", "", false); Parameter characterParameter = parser.addMandatoryCharacterParameter("Character", "c", "desc"); Parameter characterArrayParam = parser.addCharacterArrayParameter("CharacterArray", "cArr", "", false); - parser.parse(); + parser.parse(args); assertEquals("stringInput", stringParam.getArgument()); assertArrayEquals(new String[]{"string", "array"}, stringArrayParam.getArgument()); @@ -435,7 +435,7 @@ public void testCombinationOfMandatoryArguments() { public void testCombinationOfMandatoryAndOptionalArguments() { String[] args = new String[]{"-s", "stringInput", "-sArr", "string", "array", "-iArr", "1", "2", "-d", "12.3", "-b", "true", "-bArr", "true", "false", "-cArr", "d", "c"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringParam = parser.addMandatoryStringParameter("String", "s", "desc"); Parameter stringArrayParam = parser.addStringArrayParameter("StringArray", "sArr", "", false); Parameter intParam = parser.addOptionalIntegerParameter("Int", "i", "desc"); @@ -446,7 +446,7 @@ public void testCombinationOfMandatoryAndOptionalArguments() { Parameter booleanArrayParam = parser.addBooleanArrayParameter("BooleanArray", "bArr", "", false); Parameter characterParameter = parser.addOptionalCharacterParameter("Character", "c", "desc"); Parameter characterArrayParam = parser.addCharacterArrayParameter("CharacterArray", "cArr", "", false); - parser.parse(); + parser.parse(args); assertEquals("stringInput", stringParam.getArgument()); assertArrayEquals(new String[]{"string", "array"}, stringArrayParam.getArgument()); @@ -464,7 +464,7 @@ public void testCombinationOfMandatoryAndOptionalArguments() { public void testGetArgumentTypes() { String[] args = new String[]{"-s", "stringInput", "-sArr", "string", "array", "-i", "12", "-iArr", "1", "2", "-d", "12.3", "-dArr", "1.2", "2.3", "-b", "true", "-bArr", "true", "false", "-c", "a", "-cArr", "d", "c"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringParam = parser.addMandatoryStringParameter("String", "s", "desc"); Parameter stringArrayParam = parser.addStringArrayParameter("StringArray", "sArr", "", false); Parameter intParam = parser.addMandatoryIntegerParameter("Int", "i", "desc"); @@ -475,7 +475,7 @@ public void testGetArgumentTypes() { Parameter booleanArrayParam = parser.addBooleanArrayParameter("BooleanArray", "bArr", "", false); Parameter characterParameter = parser.addMandatoryCharacterParameter("Character", "c", "desc"); Parameter characterArrayParam = parser.addCharacterArrayParameter("CharacterArray", "cArr", "", false); - parser.parse(); + parser.parse(args); assertEquals(String.class, stringParam.getArgument().getClass()); assertEquals(String[].class, stringArrayParam.getArgument().getClass()); @@ -503,7 +503,7 @@ public void testGetArgumentOf() { "-c", "x", "-cArr", "a", "z" }; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); parser.addMandatoryStringParameter("String", "s", "desc"); parser.addStringArrayParameter("StringArray", "sArr", "", false); @@ -516,7 +516,7 @@ public void testGetArgumentOf() { parser.addMandatoryCharacterParameter("Character", "c", "desc"); parser.addCharacterArrayParameter("CharacterArray", "cArr", "", false); - parser.parse(); + parser.parse(args); // Verifying results of getArgumentOf method assertEquals("stringInput", parser.getArgumentOf("--String")); @@ -542,7 +542,7 @@ public void testCombinationsOfCommandsAndFlags() { "-iArr", "1", "2", "command2" }; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringPar = parser.addMandatoryStringParameter("String", "s", "desc"); Parameter stringArrPar = parser.addStringArrayParameter("StringArray", "sArr", "", false); Parameter intPar = parser.addMandatoryIntegerParameter("Int", "i", "desc"); @@ -550,7 +550,7 @@ public void testCombinationsOfCommandsAndFlags() { Command command1 = parser.addCommand("command1", "c1", null); Command command2 = parser.addCommand("command2", "c2", null); Command command3 = parser.addCommand("command3", "c3", null); - parser.parse(); + parser.parse(args); assertEquals("stringInput", parser.getArgumentOf("--String")); assertArrayEquals(new String[]{"arr1", "arr2"}, stringArrPar.getArgument()); diff --git a/src/test/TestArgsExceptions.java b/src/test/TestArgsExceptions.java index f77ac2a..7de16cd 100644 --- a/src/test/TestArgsExceptions.java +++ b/src/test/TestArgsExceptions.java @@ -11,11 +11,11 @@ public class TestArgsExceptions { @Test public void testHelpForSingleFlag() { String[] args = {"-pf4", "--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter doub = parser.addDefaultDoubleParameter("parameterFlag4", "pf4", "description", 5.6); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -34,7 +34,7 @@ public void testHelpForSingleFlag() { @Test public void testHelpWithEachParameter() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter mandatoryString = parser.addMandatoryStringParameter("mandatory_string", "ms", "mandatory string description"); Parameter optionalString = parser.addOptionalStringParameter("optional_string", "os", "optional string description"); @@ -56,7 +56,7 @@ public void testHelpWithEachParameter() { Parameter optionalBoolean = parser.addOptionalBooleanParameter("optional_boolean", "ob", "optional boolean description"); Parameter defaultBoolean = parser.addDefaultBooleanParameter("default_boolean", "db", "default boolean description", true); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -109,7 +109,7 @@ public void testHelpWithEachParameter() { @Test public void testHelpWithArrayParameters() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringArray = parser.addStringArrayParameter("stringArrayParam", "hap", "descr", true); Parameter defaultStringArray = parser.addDefaultStringArrayParameter("stringArray", "sAr", "descr", new String[]{"string1", "string2", "string3"}); @@ -122,7 +122,7 @@ public void testHelpWithArrayParameters() { Parameter characterArray = parser.addCharacterArrayParameter("characterArrayParam", "cap", "description", true); Parameter defaultCharacterArray = parser.addDefaultCharacterArrayParameter("characterArray", "ca", "description", new Character[]{'a', 'b', 'c'}); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -165,11 +165,11 @@ public void testHelpWithArrayParameters() { @Test public void testHelpWithCommand() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Command command = parser.addCommand("command", "c", "this is a command"); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -186,13 +186,13 @@ public void testHelpWithCommand() { @Test public void testHelpWithCommandsAndParameters() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Command command = parser.addCommand("command", "c", "this is a command"); Parameter newParam1 = parser.addMandatoryStringParameter("newParam1", "np1", "this is the first new parameter"); Parameter newParam2 = parser.addOptionalIntegerParameter("newParam2", "np2", "this is the second new parameter"); Command newCommand = parser.addCommand("newCommand", "nc", "this is another command"); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -219,11 +219,11 @@ public void testHelpWithCommandsAndParameters() { @Test public void testOneCommandAndOneParameter() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Command command = parser.addCommand("command", "c", "this is a command"); Parameter newParam1 = parser.addMandatoryStringParameter("newParam1", "np1", "this is the first new parameter"); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -246,7 +246,7 @@ public void testOneCommandAndOneParameter() { @Test public void testHelpWithNewLineInDescription() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter longString = parser.addDefaultStringParameter("longString", "ls", "This description is so long, it will " + @@ -255,7 +255,7 @@ public void testHelpWithNewLineInDescription() { "this/path/is/so/long/it/is/actually/longer/than/any" + "/existing/path/that/I/have/on/my/PC/Do/You/Know/The/Word" + "Oberwesedampfschifffahrtsgesellschaftskapitän"); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -277,7 +277,7 @@ public void testHelpWithNewLineInDescription() { @Test public void testNoDescriptionAvailable() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter strParam = parser.addMandatoryStringParameter("string", "s", ""); Parameter intParam = parser.addOptionalIntegerParameter("integer", "i", null); @@ -286,7 +286,7 @@ public void testNoDescriptionAvailable() { Parameter doubleParam = parser.addMandatoryDoubleParameter("double", "d", null); Parameter strArrParam = parser.addStringArrayParameter("stringArray", "sArr", null, false); - Exception exception = assertThrows(CalledForHelpNotification.class, parser::parseUnchecked); + Exception exception = assertThrows(CalledForHelpNotification.class, () -> parser.parseUnchecked(args)); String expected = """ ############################################### HELP ############################################### @@ -318,21 +318,21 @@ public void testNoDescriptionAvailable() { @Test public void testHelpAtWrongPosition() { String[] args = {"--file", "file.txt", "--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); - Exception exception = assertThrows(HelpAtWrongPositionArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(HelpAtWrongPositionArgsException.class, () -> parser.parseUnchecked(args)); } @Test public void testHelpBeforeFlag() { String[] args = {"--help", "--file"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); - Exception exception = assertThrows(HelpAtWrongPositionArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(HelpAtWrongPositionArgsException.class, () -> parser.parseUnchecked(args)); } // FlagAlreadyProvidedArgsException @@ -340,12 +340,12 @@ public void testHelpBeforeFlag() { @Test public void testSameFlagProvidedTwice() { String[] args = {"--file", "file.txt", "-f", "file2.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter file2 = parser.addMandatoryStringParameter("file2", "f2", "descr"); - Exception exception = assertThrows(FlagAlreadyProvidedArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(FlagAlreadyProvidedArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" Redundant specification of arguments to: --file/-f @@ -359,12 +359,12 @@ public void testSameFlagProvidedTwice() { @Test public void testGetArgumentAsDoubleWithWrongInput() { String[] args = {"--file", "file.txt", "--double", "5.5.5"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter doub = parser.addMandatoryDoubleParameter("double", "d", "descr"); - Exception exception = assertThrows(InvalidArgTypeArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(InvalidArgTypeArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new InvalidArgTypeArgsException("--double", "Double", "Unsupported type!").getMessage(), exception.getMessage()); } @@ -373,26 +373,26 @@ public void testGetArgumentAsDoubleWithWrongInput() { @Test public void testMandatoryArgMissing() { String[] args = {"--file", "file.txt", "--optional", "optional.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "s", "descr"); Parameter optional = parser.addMandatoryStringParameter("optional", "o", "descr"); - Exception exception = assertThrows(MandatoryArgNotProvidedArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(MandatoryArgNotProvidedArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new MandatoryArgNotProvidedArgsException("Mandatory parameters are missing:\n--save").getMessage(), exception.getMessage()); } @Test public void testMultipleMandatoryArgumentsMissing() { String[] args = {"--load", "file.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter load = parser.addMandatoryStringParameter("load", "l", "descr"); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "s", "descr"); - Exception exception = assertThrows(MandatoryArgNotProvidedArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(MandatoryArgNotProvidedArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new MandatoryArgNotProvidedArgsException("Mandatory parameters are missing:\n--save\n--file").getMessage(), exception.getMessage()); } @@ -401,24 +401,24 @@ public void testMultipleMandatoryArgumentsMissing() { @Test public void testMissingArgument() { String[] args = {"--file", "--save", "save.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "m", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "s", "descr"); - Exception exception = assertThrows(MissingArgArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(MissingArgArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new MissingArgArgsException("--file").getMessage(), exception.getMessage()); } @Test public void testMissingLastArgument() { String[] args = {"--file", "file.txt", "--save"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("--file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("--save", "s", "descr"); - Exception exception = assertThrows(MissingArgArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(MissingArgArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new MissingArgArgsException("--save").getMessage(), exception.getMessage()); } @@ -427,11 +427,11 @@ public void testMissingLastArgument() { @Test public void testNoArgumentsProvidedWithMandatoryParams() { String[] args = {}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter mandatoryParam = parser.addMandatoryStringParameter("optional", "o", null); - Exception exception = assertThrows(NoArgumentsProvidedArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(NoArgumentsProvidedArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" No arguments provided @@ -443,11 +443,11 @@ public void testNoArgumentsProvidedWithMandatoryParams() { @Test public void testNoArgumentsProvidedWithOnlyOptionalParams() { // just checks if the programs still runs if only optionals are defined String[] args = {}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter stringParam = parser.addOptionalStringParameter("optional", "o", null); - assertDoesNotThrow(parser::parseUnchecked); + assertDoesNotThrow(() -> parser.parseUnchecked(args)); } // TooManyArgumentsArgsException @@ -455,12 +455,12 @@ public void testNoArgumentsProvidedWithOnlyOptionalParams() { // just checks if @Test public void testTooManyArguments() { String[] args = {"--file", "file.txt", "--save", "save.txt", "extra"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "s", "descr"); - Exception exception = assertThrows(TooManyArgumentsArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(TooManyArgumentsArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(new TooManyArgumentsArgsException("--save").getMessage(), exception.getMessage()); } @@ -469,12 +469,12 @@ public void testTooManyArguments() { @Test public void testUnknownFlag() { String[] args = {"-w", "file.txt", "-s", "save.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "s", "descr"); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" unknown flag or command: -w @@ -486,12 +486,12 @@ public void testUnknownFlag() { @Test public void testUnknownFlagWithMultipleFlagsAndWrongInput() { String[] args = {"-f", "file.txt", "--save", "save.txt", "-s"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("save", "w", "descr"); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" unknown flag or command: -s @@ -504,12 +504,12 @@ public void testUnknownFlagWithMultipleFlagsAndWrongInput() { @Test public void testMissingShorts() { String[] args = {"-f", "/to/file", "--save", "save.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("--file", "m", "descr"); Parameter save = parser.addMandatoryStringParameter("--save", "s", null); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" unknown flag or command: -f @@ -522,12 +522,12 @@ public void testMissingShorts() { @Test public void testMisspelledHelp() { String[] args = {"--hp"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("--file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("--save", "s", null); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" unknown flag or command: --hp @@ -540,12 +540,12 @@ public void testMisspelledHelp() { @Test public void testSuggestionForFullFlag() { String[] args = {"-f", "/to/file", "--sve", "save.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("--file", "f", "descr"); Parameter save = parser.addMandatoryStringParameter("--save", "s", null); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); assertEquals(""" unknown flag or command: --sve @@ -558,11 +558,11 @@ public void testSuggestionForFullFlag() { @Test public void testNoFlags() { String[] args = {"file.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter string = parser.addMandatoryStringParameter("file", "f", "descr"); - Exception exception = assertThrows(UnknownFlagArgsException.class, parser::parseUnchecked); + Exception exception = assertThrows(UnknownFlagArgsException.class, () -> parser.parseUnchecked(args)); String expected = """ unknown flag or command: file.txt @@ -580,7 +580,7 @@ public void testNoFlags() { @Test public void testDefinitionOfSameFlagTwice() { String[] args = {"--file", "file.txt", "--file2", "file2.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); parser.addMandatoryStringParameter("file", "f", "descr"); @@ -595,26 +595,27 @@ public void testDefinitionOfSameFlagTwice() { @Test public void testDoubleParseCall() { String[] args = {"--file", "file.txt", "--file2", "file2.txt"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); Parameter file = parser.addMandatoryStringParameter("file", "f", "descr"); Parameter file2 = parser.addMandatoryStringParameter("file2", "f2", "descr"); - parser.parse(); + parser.parse(args); - Exception exception = assertThrows(IllegalStateException.class, parser::parseUnchecked); + Exception exception = assertThrows(IllegalStateException.class, () -> parser.parseUnchecked(args)); assertEquals(new IllegalStateException(".parse() was already called!").getMessage(), exception.getMessage()); } @Test public void testArgsIsNull() { String[] args = null; - Exception exception = assertThrows(IllegalArgumentException.class, () -> new ArgsParser(args)); + ArgsParser parser = new ArgsParser(); + Exception exception = assertThrows(IllegalArgumentException.class, () -> parser.parseUnchecked(null)); assertEquals("Args cannot be null!", exception.getMessage()); } @Test public void testTryToUseHelpAsFlagName() { String[] args = {"--help"}; - ArgsParser parser = new ArgsParser(args); + ArgsParser parser = new ArgsParser(); assertThrows(IllegalArgumentException.class, () -> { parser.addMandatoryStringParameter("help", "f", ""); From e1c9ab3a44d580e5fff44fa26aab3116610055d1 Mon Sep 17 00:00:00 2001 From: Niklas Date: Sat, 7 Dec 2024 12:34:24 +0100 Subject: [PATCH 2/2] docstring corrected --- src/ArgsParser/Command.java | 2 +- src/ArgsParser/Parameter.java | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/ArgsParser/Command.java b/src/ArgsParser/Command.java index 03fee41..d948f16 100644 --- a/src/ArgsParser/Command.java +++ b/src/ArgsParser/Command.java @@ -60,7 +60,7 @@ protected void setCommand() { * Checks if the command has been provided after the arguments were parsed. * * @return true if the command is provided, false otherwise. - * @throws IllegalArgumentException if the {@link ArgsParser#parse()} method was not called before checking the command. + * @throws IllegalArgumentException if the {@link ArgsParser#parse(String[] args)} method was not called before checking the command. */ public boolean isProvided() throws IllegalArgumentException { if (!argsParser.parseArgsWasCalled()) throw new IllegalStateException("parse() was not called before trying to check the command!"); diff --git a/src/ArgsParser/Parameter.java b/src/ArgsParser/Parameter.java index ae91993..bc9c430 100644 --- a/src/ArgsParser/Parameter.java +++ b/src/ArgsParser/Parameter.java @@ -108,7 +108,7 @@ protected boolean hasArgument() { /** * getter method for the argument attribute * @return argument as String - * @throws IllegalStateException if {@link ArgsParser#parse()} was not called before trying to access this argument + * @throws IllegalStateException if {@link ArgsParser#parse(String[] args)} was not called before trying to access this argument */ public T getArgument() throws IllegalStateException { if (!argsParser.parseArgsWasCalled()) throw new IllegalStateException("parse() was not called before trying to access the argument!");