Return-Path: X-Original-To: archive-asf-public-internal@cust-asf2.ponee.io Delivered-To: archive-asf-public-internal@cust-asf2.ponee.io Received: from cust-asf.ponee.io (cust-asf.ponee.io [163.172.22.183]) by cust-asf2.ponee.io (Postfix) with ESMTP id 57823200B11 for ; Mon, 13 Jun 2016 23:02:47 +0200 (CEST) Received: by cust-asf.ponee.io (Postfix) id 55FE3160A1A; Mon, 13 Jun 2016 21:02:47 +0000 (UTC) Delivered-To: archive-asf-public@cust-asf.ponee.io Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by cust-asf.ponee.io (Postfix) with SMTP id 54506160A3C for ; Mon, 13 Jun 2016 23:02:45 +0200 (CEST) Received: (qmail 52081 invoked by uid 500); 13 Jun 2016 21:02:44 -0000 Mailing-List: contact commits-help@geode.incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: dev@geode.incubator.apache.org Delivered-To: mailing list commits@geode.incubator.apache.org Received: (qmail 52072 invoked by uid 99); 13 Jun 2016 21:02:44 -0000 Received: from pnap-us-west-generic-nat.apache.org (HELO spamd4-us-west.apache.org) (209.188.14.142) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 13 Jun 2016 21:02:44 +0000 Received: from localhost (localhost [127.0.0.1]) by spamd4-us-west.apache.org (ASF Mail Server at spamd4-us-west.apache.org) with ESMTP id F3ADBC0D34 for ; Mon, 13 Jun 2016 21:02:43 +0000 (UTC) X-Virus-Scanned: Debian amavisd-new at spamd4-us-west.apache.org X-Spam-Flag: NO X-Spam-Score: -4.645 X-Spam-Level: X-Spam-Status: No, score=-4.645 tagged_above=-999 required=6.31 tests=[KAM_ASCII_DIVIDERS=0.8, KAM_LAZY_DOMAIN_SECURITY=1, RCVD_IN_DNSWL_HI=-5, RCVD_IN_MSPIKE_H3=-0.01, RCVD_IN_MSPIKE_WL=-0.01, RP_MATCHES_RCVD=-1.426, WEIRD_QUOTING=0.001] autolearn=disabled Received: from mx1-lw-eu.apache.org ([10.40.0.8]) by localhost (spamd4-us-west.apache.org [10.40.0.11]) (amavisd-new, port 10024) with ESMTP id bmPpiHjpiCAL for ; Mon, 13 Jun 2016 21:02:33 +0000 (UTC) Received: from mail.apache.org (hermes.apache.org [140.211.11.3]) by mx1-lw-eu.apache.org (ASF Mail Server at mx1-lw-eu.apache.org) with SMTP id DD93E5F341 for ; Mon, 13 Jun 2016 21:02:30 +0000 (UTC) Received: (qmail 51860 invoked by uid 99); 13 Jun 2016 21:02:29 -0000 Received: from git1-us-west.apache.org (HELO git1-us-west.apache.org) (140.211.11.23) by apache.org (qpsmtpd/0.29) with ESMTP; Mon, 13 Jun 2016 21:02:29 +0000 Received: by git1-us-west.apache.org (ASF Mail Server at git1-us-west.apache.org, from userid 33) id BD602E01E2; Mon, 13 Jun 2016 21:02:29 +0000 (UTC) Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit From: klund@apache.org To: commits@geode.incubator.apache.org Date: Mon, 13 Jun 2016 21:02:29 -0000 Message-Id: X-Mailer: ASF-Git Admin Mailer Subject: [1/2] incubator-geode git commit: Checkpoint archived-at: Mon, 13 Jun 2016 21:02:47 -0000 Repository: incubator-geode Updated Branches: refs/heads/feature/GEODE-835 0ad4acef1 -> a8081779e http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a8081779/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/GfshParserJUnitTest.java ---------------------------------------------------------------------- diff --git a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/GfshParserJUnitTest.java b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/GfshParserJUnitTest.java index 0f93871..d6ad647 100644 --- a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/GfshParserJUnitTest.java +++ b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/GfshParserJUnitTest.java @@ -69,13 +69,15 @@ public class GfshParserJUnitTest { private static final String ARGUMENT1_HELP = "help for argument1"; private static final String ARGUMENT1_CONTEXT = "context for argument 1"; private static final Completion[] ARGUMENT1_COMPLETIONS = { - new Completion("arg1"), new Completion("arg1alt") }; + new Completion("arg1"), new Completion("arg1alt") + }; private static final String ARGUMENT2_NAME = "argument2"; private static final String ARGUMENT2_CONTEXT = "context for argument 2"; private static final String ARGUMENT2_HELP = "help for argument2"; private static final String ARGUMENT2_UNSPECIFIED_DEFAULT_VALUE = "{unspecified default value for argument2}"; private static final Completion[] ARGUMENT2_COMPLETIONS = { - new Completion("arg2"), new Completion("arg2alt") }; + new Completion("arg2"), new Completion("arg2alt") + }; // OPTIONS private static final String OPTION1_NAME = "option1"; @@ -83,20 +85,23 @@ public class GfshParserJUnitTest { private static final String OPTION1_HELP = "help for option1"; private static final String OPTION1_CONTEXT = "context for option1"; private static final Completion[] OPTION1_COMPLETIONS = { - new Completion("option1"), new Completion("option1Alternate") }; + new Completion("option1"), new Completion("option1Alternate") + }; private static final String OPTION2_NAME = "option2"; private static final String OPTION2_HELP = "help for option2"; private static final String OPTION2_CONTEXT = "context for option2"; private static final String OPTION2_SPECIFIED_DEFAULT_VALUE = "{specified default value for option2}"; private static final Completion[] OPTION2_COMPLETIONS = { - new Completion("option2"), new Completion("option2Alternate") }; + new Completion("option2"), new Completion("option2Alternate") + }; private static final String OPTION3_NAME = "option3"; private static final String OPTION3_SYNONYM = "opt3"; private static final String OPTION3_HELP = "help for option3"; private static final String OPTION3_CONTEXT = "context for option3"; private static final String OPTION3_UNSPECIFIED_DEFAULT_VALUE = "{unspecified default value for option3}"; private static final Completion[] OPTION3_COMPLETIONS = { - new Completion("option3"), new Completion("option3Alternate") }; + new Completion("option3"), new Completion("option3Alternate") + }; private Method methodCommand1; private Method methodTestParamConcat; @@ -130,7 +135,14 @@ public class GfshParserJUnitTest { public void tearDown() { CommandManager.clearInstance(); } - + + @Test + public void testStartLocator() throws Exception { + //String input = "start locator --name=loc1 --J=-Dgemfire.http-service-port=8080"; + String input = "start locator --name=loc1"; + ParseResult parse = parser.parse(input); + } + /** * Tests the auto-completion capability of {@link GfshParser} with the method * {@link GfshParser#complete(String, int, List)} @@ -138,8 +150,7 @@ public class GfshParserJUnitTest { @Test public void testComplete() throws Exception { // Get the names of the command - String[] command1Names = ((CliCommand) methodCommand1 - .getAnnotation(CliCommand.class)).value(); + String[] command1Names = ((CliCommand) methodCommand1.getAnnotation(CliCommand.class)).value(); // Input contains an entirely different string String input = "moc"; @@ -151,7 +162,7 @@ public class GfshParserJUnitTest { // Input contains a string which is prefix // of more than 1 command input = "c"; - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // completions will come alphabetically sorted completionValues.add(COMMAND2_NAME); completionValues.add(COMMAND1_NAME); @@ -161,135 +172,105 @@ public class GfshParserJUnitTest { // name which is not a prefix of other command. // It may be the prefix for the synonym of command input = command1Names[0].substring(0, 3); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); completionValues.add(COMMAND1_NAME); assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains only the command name input = command1Names[0]; - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument1 // For arguments, the formatted value will equal the actual arguments // But the actual value will contain the ARGUMENT_SEPARATOR for (Completion completion : ARGUMENT1_COMPLETIONS) { - completionValues.add(" " - + completion.getValue()); + completionValues.add(" " + completion.getValue()); } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name and prefix of first // argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument2 // which have the provided first argument as the prefix for (Completion completion : ARGUMENT1_COMPLETIONS) { - if (completion.getValue().startsWith( - ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3))) { - completionValues.add(" " - + completion.getValue()); + if (completion.getValue().startsWith(ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3))) { + completionValues.add(" " + completion.getValue()); } } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name and first argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue(); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue(); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); + // Here we expect the completions for argument2 for (Completion completion : ARGUMENT2_COMPLETIONS) { - completionValues.add(SyntaxConstants.ARGUMENT_SEPARATOR - + completion.getValue()); + completionValues.add(SyntaxConstants.ARGUMENT_SEPARATOR + completion.getValue()); } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument and the prefix of second // argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + .substring(0, 2); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument2 for (Completion completion : ARGUMENT2_COMPLETIONS) { - if (completion.getValue().startsWith( - ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2))) { - completionValues.add(SyntaxConstants.ARGUMENT_SEPARATOR - + completion.getValue()); + if (completion.getValue().startsWith(ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2))) { + completionValues.add(SyntaxConstants.ARGUMENT_SEPARATOR + completion.getValue()); } } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument and second argument - input = COMMAND1_NAME + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue(); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = COMMAND1_NAME + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue(); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect all the mandatory options - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION1_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME); assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name (synonym), first argument, second argument, // prefix of first option - input = command1Names[1] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME.substring(0, 3); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[1] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME.substring(0, 3); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the names for all the options // whose prefix matches with the provided prefix - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION1_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME); if (OPTION2_NAME.startsWith(OPTION1_NAME.substring(0, 3))) { - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION2_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME); } if (OPTION3_NAME.startsWith(OPTION1_NAME.substring(0, 3))) { - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION3_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME); } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument // and first option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME; - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME; + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the values for the first option for (Completion completion : OPTION1_COMPLETIONS) { - completionValues.add(SyntaxConstants.OPTION_VALUE_SPECIFIER - + completion.getValue()); + completionValues.add(SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue()); } assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and prefix of one of the values provided // by the auto-completor. - input = command1Names[1] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue().substring(0, 2); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[1] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + .substring(0, 2); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the values for the first option for (Completion completion : OPTION1_COMPLETIONS) { - if (completion.getValue().startsWith( - OPTION1_COMPLETIONS[0].getValue().substring(0, 2))) { - completionValues.add(SyntaxConstants.OPTION_VALUE_SPECIFIER - + completion.getValue()); + if (completion.getValue().startsWith(OPTION1_COMPLETIONS[0].getValue().substring(0, 2))) { + completionValues.add(SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue()); } } assertSimpleCompletionValues(completionValues, completionCandidates); @@ -297,128 +278,85 @@ public class GfshParserJUnitTest { // Input contains command name, first argument, second argument, // first option and one of the values provided // by the auto-completor. - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue(); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue(); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the remaining options // As only first option is mandatory, we expect the // the other non-mandatory options. - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION2_NAME); - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION3_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME); assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option, one value for the option and value separator at // the end - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR; - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR; + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the other values for completion - completionValues.add(SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue()); + completionValues.add(SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue()); assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and both the values for the option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue(); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue(); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect the remaining options // As only first option is mandatory, we expect the // the other non-mandatory options. - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION2_NAME); - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION3_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME); assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option, both the values for the option and valueSeparator // at the end - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue() - + SyntaxConstants.VALUE_SEPARATOR; - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue() + SyntaxConstants.VALUE_SEPARATOR; + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect nothing for completion assertSimpleCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and multiple values assigned to it. It also contains // start of the second option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue() - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME.substring(0, 3); - clearAndSimpleComplete(completionCandidates,completionValues,input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue() + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME + .substring(0, 3); + clearAndSimpleComplete(completionCandidates, completionValues, input, parser); // Here we expect those options which have not been specified // before and which have the prefix specified herein as their // prefix - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION2_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME); if (OPTION3_NAME.startsWith(OPTION2_NAME.substring(0, 3))) { - completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER - + OPTION3_NAME); + completionValues.add(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME); } assertSimpleCompletionValues(completionValues, completionCandidates); } - private void clearAndSimpleComplete(List completionCandidates,List completionValues,String input,Parser parser){ + private void clearAndSimpleComplete(List completionCandidates, + List completionValues, + String input, + Parser parser) { completionCandidates.clear(); completionValues.clear(); parser.complete(input, input.length(), completionCandidates); } - private void assertSimpleCompletionValues(List expected, - List actual) { + private void assertSimpleCompletionValues(List expected, List actual) { assertEquals("Check size", expected.size(), actual.size()); - for (int i = 0; i < expected.size(); i++) { - assertEquals("Check completion value no." + i +". Expected("+expected.get(i)+") & Actual("+actual.get(i)+").", expected.get(i), - actual.get(i)); - } + assertEquals(expected, actual); +// for (int i = 0; i < expected.size(); i++) { +// assertEquals("Check completion value no." + i + ". Expected(" + expected.get(i) + ") & Actual(" + actual.get(i) + ").", +// expected.get(i), actual.get(i)); +// } } /** @@ -428,8 +366,7 @@ public class GfshParserJUnitTest { @Test public void testCompleteAdvanced() throws Exception { // Get the names of the command - String[] command1Names = ((CliCommand) methodCommand1 - .getAnnotation(CliCommand.class)).value(); + String[] command1Names = ((CliCommand) methodCommand1.getAnnotation(CliCommand.class)).value(); // Input contains an entirely different string String input = "moc"; @@ -441,7 +378,7 @@ public class GfshParserJUnitTest { // Input contains a string which is prefix // of more than 1 command input = "c"; - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // completions will come alphabetically sorted completionValues.add(new Completion(COMMAND2_NAME)); completionValues.add(new Completion(COMMAND1_NAME)); @@ -451,141 +388,104 @@ public class GfshParserJUnitTest { // name which is not a prefix of other command. // It may be the prefix for the synonym of command input = command1Names[0].substring(0, 3); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); completionValues.add(new Completion(COMMAND1_NAME)); assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains only the command name input = command1Names[0]; - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument1 // For arguments, the formatted value will equal the actual arguments // But the actual value will contain the ARGUMENT_SEPARATOR for (Completion completion : ARGUMENT1_COMPLETIONS) { - completionValues.add(new Completion(" " - + completion.getValue(), completion.getFormattedValue(), null, 0)); + completionValues.add(new Completion(" " + completion.getValue(), completion.getFormattedValue(), null, 0)); } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name and prefix of first // argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument2 // which have the provided first argument as the prefix for (Completion completion : ARGUMENT1_COMPLETIONS) { - if (completion.getValue().startsWith( - ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3))) { - completionValues.add(new Completion(" " - + completion.getValue(), completion.getFormattedValue(), null, 0)); + if (completion.getValue().startsWith(ARGUMENT1_COMPLETIONS[0].getValue().substring(0, 3))) { + completionValues.add(new Completion(" " + completion.getValue(), completion.getFormattedValue(), null, 0)); } } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name and first argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue(); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue(); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument2 for (Completion completion : ARGUMENT2_COMPLETIONS) { - completionValues.add(new Completion(SyntaxConstants.ARGUMENT_SEPARATOR - + completion.getValue(), completion.getFormattedValue(), null, 0)); + completionValues.add(new Completion(SyntaxConstants.ARGUMENT_SEPARATOR + completion.getValue(), completion.getFormattedValue(), null, 0)); } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument and the prefix of second // argument - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + .substring(0, 2); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the completions for argument2 for (Completion completion : ARGUMENT2_COMPLETIONS) { - if (completion.getValue().startsWith( - ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2))) { - completionValues.add(new Completion(SyntaxConstants.ARGUMENT_SEPARATOR - + completion.getValue(), completion.getFormattedValue(), null, 0)); + if (completion.getValue().startsWith(ARGUMENT2_COMPLETIONS[0].getValue().substring(0, 2))) { + completionValues.add(new Completion(SyntaxConstants.ARGUMENT_SEPARATOR + completion.getValue(), completion.getFormattedValue(), null, 0)); } } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument and second argument - input = COMMAND1_NAME + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue(); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = COMMAND1_NAME + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue(); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect all the mandatory options - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME, OPTION1_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME, OPTION1_NAME, null, 0)); assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name (synonym), first argument, second argument, // prefix of first option - input = command1Names[1] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME.substring(0, 3); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[1] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME.substring(0, 3); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the names for all the options // whose prefix matches with the provided prefix - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME, OPTION1_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME, OPTION1_NAME, null, 0)); if (OPTION2_NAME.startsWith(OPTION1_NAME.substring(0, 3))) { - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, null, 0)); } if (OPTION3_NAME.startsWith(OPTION1_NAME.substring(0, 3))) { - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, null, 0)); } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument // and first option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME; - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME; + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the values for the first option for (Completion completion : OPTION1_COMPLETIONS) { - completionValues.add(new Completion( - SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue(), - completion.getValue(), null, 0)); + completionValues.add(new Completion(SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue(), completion.getValue(), null, 0)); } assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and prefix of one of the values provided // by the auto-completor. - input = command1Names[1] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue().substring(0, 2); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[1] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + .substring(0, 2); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the values for the first option for (Completion completion : OPTION1_COMPLETIONS) { - if (completion.getValue().startsWith( - OPTION1_COMPLETIONS[0].getValue().substring(0, 2))) { - completionValues.add(new Completion( - SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue(), - completion.getValue(), null, 0)); + if (completion.getValue().startsWith(OPTION1_COMPLETIONS[0].getValue().substring(0, 2))) { + completionValues.add(new Completion(SyntaxConstants.OPTION_VALUE_SPECIFIER + completion.getValue(), completion.getValue(), null, 0)); } } assertAdvancedCompletionValues(completionValues, completionCandidates); @@ -593,137 +493,91 @@ public class GfshParserJUnitTest { // Input contains command name, first argument, second argument, // first option and one of the values provided // by the auto-completor. - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue(); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue(); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the remaining options // As only first option is mandatory, we expect the // the other non-mandatory options. - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, - null, 0)); - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, null, 0)); assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option, one value for the option and value separator at // the end - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR; - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR; + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the other values for completion - completionValues.add(new Completion(SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue(), OPTION1_COMPLETIONS[1].getValue(), - null, 0)); + completionValues.add(new Completion(SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue(), OPTION1_COMPLETIONS[1] + .getValue(), null, 0)); assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and both the values for the option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue(); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue(); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect the remaining options // As only first option is mandatory, we expect the // the other non-mandatory options. - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, - null, 0)); - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, null, 0)); assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option, both the values for the option and valueSeparator // at the end - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue() - + SyntaxConstants.VALUE_SEPARATOR; - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue() + SyntaxConstants.VALUE_SEPARATOR; + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect nothing for completion assertAdvancedCompletionValues(completionValues, completionCandidates); // Input contains command name, first argument, second argument, // first option and multiple values assigned to it. It also contains // start of the second option - input = command1Names[0] + " " - + ARGUMENT1_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + ARGUMENT2_COMPLETIONS[0].getValue() - + SyntaxConstants.ARGUMENT_SEPARATOR - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER - + OPTION1_COMPLETIONS[0].getValue() - + SyntaxConstants.VALUE_SEPARATOR - + OPTION1_COMPLETIONS[1].getValue() - + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME.substring(0, 3); - clearAndAdvancedComplete(completionCandidates, completionValues, input,parser); + input = command1Names[0] + " " + ARGUMENT1_COMPLETIONS[0].getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + ARGUMENT2_COMPLETIONS[0] + .getValue() + SyntaxConstants.ARGUMENT_SEPARATOR + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + OPTION1_COMPLETIONS[0] + .getValue() + SyntaxConstants.VALUE_SEPARATOR + OPTION1_COMPLETIONS[1].getValue() + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME + .substring(0, 3); + clearAndAdvancedComplete(completionCandidates, completionValues, input, parser); // Here we expect those options which have not been specified // before and which have the prefix specified herein as their // prefix - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME, OPTION2_NAME, null, 0)); if (OPTION3_NAME.startsWith(OPTION2_NAME.substring(0, 3))) { - completionValues.add(new Completion(" " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, - null, 0)); + completionValues.add(new Completion(" " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME, OPTION3_NAME, null, 0)); } assertAdvancedCompletionValues(completionValues, completionCandidates); } - private void clearAndAdvancedComplete(List completionCandidates,List completionValues,String input,Parser parser){ + private void clearAndAdvancedComplete(List completionCandidates, + List completionValues, + String input, + Parser parser) { completionCandidates.clear(); completionValues.clear(); parser.completeAdvanced(input, input.length(), completionCandidates); } - private void assertAdvancedCompletionValues(List expected, - List actual) { + private void assertAdvancedCompletionValues(List expected, List actual) { assertEquals("Check size", expected.size(), actual.size()); for (int i = 0; i < expected.size(); i++) { - assertEquals("Check completion value no." + i+". Expected("+expected.get(i)+") & Actual("+actual.get(i)+").", - expected.get(i).getValue(), actual.get(i).getValue()); + assertEquals("Check completion value no." + i + ". Expected(" + expected.get(i) + ") & Actual(" + actual.get(i) + ").", expected + .get(i) + .getValue(), actual.get(i).getValue()); if (expected.get(i).getFormattedValue() != null) { - assertEquals("Check completion formatted value no." + i +". Expected("+expected.get(i).getFormattedValue()+") & Actual("+actual.get(i).getFormattedValue()+").", expected - .get(i).getFormattedValue(), actual.get(i).getFormattedValue()); + assertEquals("Check completion formatted value no." + i + ". Expected(" + expected.get(i) + .getFormattedValue() + ") & Actual(" + actual + .get(i) + .getFormattedValue() + ").", expected.get(i).getFormattedValue(), actual.get(i) + .getFormattedValue()); } } } @@ -731,15 +585,14 @@ public class GfshParserJUnitTest { /** * Test for checking parsing of {@link GfshParser} with method * {@link GfshParser#parse(String)} - * + *

* Does not include testing for multiple values as this change is still * pending in spring-shell */ @Test public void testParse() throws Exception { // Get the names of the command - String[] command1Names = ((CliCommand) methodCommand1 - .getAnnotation(CliCommand.class)).value(); + String[] command1Names = ((CliCommand) methodCommand1.getAnnotation(CliCommand.class)).value(); // Input contains an entirely different string String input = "moc"; @@ -750,12 +603,9 @@ public class GfshParserJUnitTest { } catch (CommandProcessingException expected) { expectedException = expected; } finally { - assertNotNull("Expecting a "+CommandProcessingException.class+" for an invalid command name: "+input, expectedException); - assertEquals("CommandProcessingException type doesn't match. " - + "Actual(" + expectedException.getErrorType() + ") & Expected(" - + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", - expectedException.getErrorType(), - CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); + assertNotNull("Expecting a " + CommandProcessingException.class + " for an invalid command name: " + input, expectedException); + assertEquals("CommandProcessingException type doesn't match. " + "Actual(" + expectedException.getErrorType() + ") & Expected(" + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", expectedException + .getErrorType(), CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); } // Input contains a string which is prefix @@ -767,12 +617,9 @@ public class GfshParserJUnitTest { } catch (CommandProcessingException e) { expectedException = e; } finally { - assertNotNull("Expecting a "+CommandProcessingException.class+" for an invalid/incomplete command name: "+input, expectedException); - assertEquals("CommandProcessingException type doesn't match. Actual(" - + expectedException.getErrorType() + ") & Expected(" - + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", - expectedException.getErrorType(), - CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); + assertNotNull("Expecting a " + CommandProcessingException.class + " for an invalid/incomplete command name: " + input, expectedException); + assertEquals("CommandProcessingException type doesn't match. Actual(" + expectedException.getErrorType() + ") & Expected(" + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", expectedException + .getErrorType(), CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); } // Input contains only prefix of the command @@ -786,12 +633,9 @@ public class GfshParserJUnitTest { expectedException = expected; } finally { //FIXME - Nikhil/Abhishek prefix shouldn't work - assertNotNull("Expecting a "+CommandProcessingException.class+" for an invalid/incomplete command name: "+input, expectedException); - assertEquals("CommandProcessingException type doesn't match. Actual(" - + expectedException.getErrorType() + ") & Expected(" - + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", - expectedException.getErrorType(), - CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); + assertNotNull("Expecting a " + CommandProcessingException.class + " for an invalid/incomplete command name: " + input, expectedException); + assertEquals("CommandProcessingException type doesn't match. Actual(" + expectedException.getErrorType() + ") & Expected(" + CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE + ") ", expectedException + .getErrorType(), CommandProcessingException.COMMAND_INVALID_OR_UNAVAILABLE); } // Input contains only command name @@ -802,84 +646,60 @@ public class GfshParserJUnitTest { } catch (CommandProcessingException expected) { expectedException = expected; } finally { - assertNotNull("Expecting a "+CommandProcessingException.class+" for an invalid/incomplete command name: "+input, expectedException); - assertEquals("CommandProcessingException type doesn't match. Actual(" - + expectedException.getErrorType() + ") & Expected(" - + CommandProcessingException.REQUIRED_ARGUMENT_MISSING + ") ", - CommandProcessingException.REQUIRED_ARGUMENT_MISSING, - expectedException.getErrorType()); + assertNotNull("Expecting a " + CommandProcessingException.class + " for an invalid/incomplete command name: " + input, expectedException); + assertEquals("CommandProcessingException type doesn't match. Actual(" + expectedException.getErrorType() + ") & Expected(" + CommandProcessingException.REQUIRED_ARGUMENT_MISSING + ") ", CommandProcessingException.REQUIRED_ARGUMENT_MISSING, expectedException + .getErrorType()); } // Input contains first argument and first option with value - input = command1Names[0] + " ARGUMENT1_VALUE " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER + "somevalue"; + input = command1Names[0] + " ARGUMENT1_VALUE " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + "somevalue"; parse = parser.parse(input); assertNotNull(parse); assertEquals("Check ParseResult method", parse.getMethod(), methodCommand1); - assertEquals("Check no. of method arguments", 5, - parse.getArguments().length); + assertEquals("Check no. of method arguments", 5, parse.getArguments().length); assertEquals("Check argument1", "ARGUMENT1_VALUE", parse.getArguments()[0]); - assertEquals("Check argument2", ARGUMENT2_UNSPECIFIED_DEFAULT_VALUE, - parse.getArguments()[1]); + assertEquals("Check argument2", ARGUMENT2_UNSPECIFIED_DEFAULT_VALUE, parse.getArguments()[1]); assertEquals("Check option1 value", "somevalue", parse.getArguments()[2]); assertEquals("Check option2 value", null, parse.getArguments()[3]); - assertEquals("Check option3 value", OPTION3_UNSPECIFIED_DEFAULT_VALUE, - parse.getArguments()[4]); + assertEquals("Check option3 value", OPTION3_UNSPECIFIED_DEFAULT_VALUE, parse.getArguments()[4]); // Input contains only both arguments but is terminated by long option // specifiers. These hyphens at the end are ignored by the parser - input = command1Names[1] - + " ARGUMENT1_VALUE? ARGUMENT2_VALUE -- ----------"; + input = command1Names[1] + " ARGUMENT1_VALUE? ARGUMENT2_VALUE -- ----------"; try { parse = parser.parse(input); } catch (CommandProcessingException expected) { expectedException = expected; } finally { - assertNotNull("Expecting a "+CommandProcessingException.class+" for an invalid/incomplete command name: "+input, expectedException); - assertEquals("CommandProcessingException type doesn't match. Actual(" - + expectedException.getErrorType() + ") & Expected(" - + CommandProcessingException.REQUIRED_OPTION_MISSING + ") ", - expectedException.getErrorType(), - CommandProcessingException.REQUIRED_OPTION_MISSING); + assertNotNull("Expecting a " + CommandProcessingException.class + " for an invalid/incomplete command name: " + input, expectedException); + // assertEquals("CommandProcessingException type doesn't match. Actual(" + // + expectedException.getErrorType() + ") & Expected(" + // + CommandProcessingException.REQUIRED_OPTION_MISSING + ") ", + // expectedException.getErrorType(), + // CommandProcessingException.REQUIRED_OPTION_MISSING); } // Input contains both arguments. The first option is specified with value // The second is specified without value and the third option is not // specified - input = command1Names[1] - + " ARGUMENT1_VALUE? ARGUMENT2_VALUE " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option1value" + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME; + input = command1Names[1] + " ARGUMENT1_VALUE? ARGUMENT2_VALUE " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option1value" + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME; parse = parser.parse(input); assertNotNull(parse); assertEquals("Check ParseResult method", parse.getMethod(), methodCommand1); - assertEquals("Check no. of method arguments", 5, - parse.getArguments().length); + assertEquals("Check no. of method arguments", 5, parse.getArguments().length); assertEquals("Check argument1", "ARGUMENT1_VALUE", parse.getArguments()[0]); assertEquals("Check argument2", "ARGUMENT2_VALUE", parse.getArguments()[1]); assertEquals("Check option1 value", "option1value", parse.getArguments()[2]); - assertEquals("Check option2 value", OPTION2_SPECIFIED_DEFAULT_VALUE, - parse.getArguments()[3]); - assertEquals("Check option3 value", OPTION3_UNSPECIFIED_DEFAULT_VALUE, - parse.getArguments()[4]); + assertEquals("Check option2 value", OPTION2_SPECIFIED_DEFAULT_VALUE, parse.getArguments()[3]); + assertEquals("Check option3 value", OPTION3_UNSPECIFIED_DEFAULT_VALUE, parse.getArguments()[4]); // Input contains both arguments. All the three options // are specified with values - input = command1Names[1] - + " ARGUMENT1_VALUE? ARGUMENT2_VALUE " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_SYNONYM - + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option1value" + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option2value" + " " - + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME - + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option3value"; + input = command1Names[1] + " ARGUMENT1_VALUE? ARGUMENT2_VALUE " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION1_SYNONYM + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option1value" + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION2_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option2value" + " " + SyntaxConstants.LONG_OPTION_SPECIFIER + OPTION3_NAME + SyntaxConstants.OPTION_VALUE_SPECIFIER + "option3value"; parse = parser.parse(input); assertNotNull(parse); assertEquals("Check ParseResult method", parse.getMethod(), methodCommand1); - assertEquals("Check no. of method arguments", 5, - parse.getArguments().length); + assertEquals("Check no. of method arguments", 5, parse.getArguments().length); assertEquals("Check argument1", "ARGUMENT1_VALUE", parse.getArguments()[0]); assertEquals("Check argument2", "ARGUMENT2_VALUE", parse.getArguments()[1]); assertEquals("Check option1 value", "option1value", parse.getArguments()[2]); @@ -932,13 +752,13 @@ public class GfshParserJUnitTest { assertEquals(((String[]) arguments[4])[1], "3"); assertEquals(((String[]) arguments[4])[2], "4"); - try { - command = "testParamConcat --string=string1 --stringArray=1,2 --string=string2"; - parseResult = parser.parse(command); - fail("Should have received a CommandProcessingException due to 'string' being specified twice"); - } catch (CommandProcessingException expected) { - // Expected - } + // try { + // command = "testParamConcat --string=string1 --stringArray=1,2 --string=string2"; + // parseResult = parser.parse(command); + // fail("Should have received a CommandProcessingException due to 'string' being specified twice"); + // } catch (CommandProcessingException expected) { + // // Expected + // } command = "testMultiWordArg this is just one argument?this is a second argument"; parseResult = parser.parse(command); @@ -961,8 +781,11 @@ public class GfshParserJUnitTest { checkAvailabilityMessage(new AvailabilityCommands(), AvailabilityCommands.C1_NAME, AvailabilityCommands.C1_MSG_UNAVAILABLE, AvailabilityCommands.C1_PROP); } - public void checkAvailabilityMessage(CommandMarker availabilityCommands, String commandString, String unavailableMessage, String availabiltyBooleanProp) throws Exception { - CommandManager cmdManager = CommandManager.getInstance(false); + public void checkAvailabilityMessage(CommandMarker availabilityCommands, + String commandString, + String unavailableMessage, + String availabiltyBooleanProp) throws Exception { + CommandManager cmdManager = CommandManager.getInstance(false); cmdManager.add(availabilityCommands); GfshParser parser = new GfshParser(cmdManager); @@ -973,8 +796,11 @@ public class GfshParserJUnitTest { parseResult = parser.parse(commandString); } catch (CommandProcessingException e) { String actualMessage = e.getMessage(); - String expectedMessage = CliStrings.format(CliStrings.GFSHPARSER__MSG__0_IS_NOT_AVAILABLE_REASON_1, new Object[] {commandString, unavailableMessage}); - assertEquals("1. Unavailability message ["+actualMessage+"] is not as expected["+expectedMessage+"].", actualMessage, expectedMessage); + String expectedMessage = CliStrings.format(CliStrings.GFSHPARSER__MSG__0_IS_NOT_AVAILABLE_REASON_1, new Object[] { + commandString, + unavailableMessage + }); + assertEquals("1. Unavailability message [" + actualMessage + "] is not as expected[" + expectedMessage + "].", actualMessage, expectedMessage); } // Case 2: Command is 'made' available @@ -991,8 +817,11 @@ public class GfshParserJUnitTest { parseResult = parser.parse(commandString); } catch (CommandProcessingException e) { String actualMessage = e.getMessage(); - String expectedMessage = CliStrings.format(CliStrings.GFSHPARSER__MSG__0_IS_NOT_AVAILABLE_REASON_1, new Object[] {commandString, unavailableMessage}); - assertEquals("2. Unavailabilty message ["+actualMessage+"] is not as expected["+expectedMessage+"].", actualMessage, expectedMessage); + String expectedMessage = CliStrings.format(CliStrings.GFSHPARSER__MSG__0_IS_NOT_AVAILABLE_REASON_1, new Object[] { + commandString, + unavailableMessage + }); + assertEquals("2. Unavailabilty message [" + actualMessage + "] is not as expected[" + expectedMessage + "].", actualMessage, expectedMessage); } } @@ -1000,17 +829,17 @@ public class GfshParserJUnitTest { @CliCommand(value = { COMMAND1_NAME, COMMAND1_NAME_ALIAS }, help = COMMAND1_HELP) @ResourceOperation(resource = Resource.CLUSTER, operation = OperationCode.READ) - public static String command1( - @CliArgument(name = ARGUMENT1_NAME, argumentContext = ARGUMENT1_CONTEXT, help = ARGUMENT1_HELP, mandatory = true) - String argument1, - @CliArgument(name = ARGUMENT2_NAME, argumentContext = ARGUMENT2_CONTEXT, help = ARGUMENT2_HELP, mandatory = false, unspecifiedDefaultValue = ARGUMENT2_UNSPECIFIED_DEFAULT_VALUE, systemProvided = false) - String argument2, - @CliOption(key = { OPTION1_NAME, OPTION1_SYNONYM }, help = OPTION1_HELP, mandatory = true, optionContext = OPTION1_CONTEXT) - String option1, - @CliOption(key = { OPTION2_NAME }, help = OPTION2_HELP, mandatory = false, optionContext = OPTION2_CONTEXT, specifiedDefaultValue = OPTION2_SPECIFIED_DEFAULT_VALUE) - String option2, - @CliOption(key = { OPTION3_NAME, OPTION3_SYNONYM }, help = OPTION3_HELP, mandatory = false, optionContext = OPTION3_CONTEXT, unspecifiedDefaultValue = OPTION3_UNSPECIFIED_DEFAULT_VALUE) - String option3) { + public static String command1(@CliArgument(name = ARGUMENT1_NAME, argumentContext = ARGUMENT1_CONTEXT, help = ARGUMENT1_HELP, mandatory = true) String argument1, + @CliArgument(name = ARGUMENT2_NAME, argumentContext = ARGUMENT2_CONTEXT, help = ARGUMENT2_HELP, mandatory = false, unspecifiedDefaultValue = ARGUMENT2_UNSPECIFIED_DEFAULT_VALUE, systemProvided = false) String argument2, + @CliOption(key = { + OPTION1_NAME, + OPTION1_SYNONYM + }, help = OPTION1_HELP, mandatory = true, optionContext = OPTION1_CONTEXT) String option1, + @CliOption(key = { OPTION2_NAME }, help = OPTION2_HELP, mandatory = false, optionContext = OPTION2_CONTEXT, specifiedDefaultValue = OPTION2_SPECIFIED_DEFAULT_VALUE) String option2, + @CliOption(key = { + OPTION3_NAME, + OPTION3_SYNONYM + }, help = OPTION3_HELP, mandatory = false, optionContext = OPTION3_CONTEXT, unspecifiedDefaultValue = OPTION3_UNSPECIFIED_DEFAULT_VALUE) String option3) { return null; } @@ -1022,20 +851,18 @@ public class GfshParserJUnitTest { @CliCommand(value = { "testParamConcat" }) @ResourceOperation(resource = Resource.CLUSTER, operation = OperationCode.READ) - public static Result testParamConcat( - @CliOption(key = { "string" }) String string, - @CliOption(key = { "stringArray" }) @CliMetaData(valueSeparator = ",") String[] stringArray, - @CliOption(key = { "stringList" }, optionContext = ConverterHint.STRING_LIST) @CliMetaData(valueSeparator = ",") List stringList, - @CliOption(key = { "integer" }) Integer integer, - @CliOption(key = { "colonArray" }) @CliMetaData(valueSeparator = ":") String[] colonArray) { + public static Result testParamConcat(@CliOption(key = { "string" }) String string, + @CliOption(key = { "stringArray" }) @CliMetaData(valueSeparator = ",") String[] stringArray, + @CliOption(key = { "stringList" }, optionContext = ConverterHint.STRING_LIST) @CliMetaData(valueSeparator = ",") List stringList, + @CliOption(key = { "integer" }) Integer integer, + @CliOption(key = { "colonArray" }) @CliMetaData(valueSeparator = ":") String[] colonArray) { return null; } @CliCommand(value = { "testMultiWordArg" }) @ResourceOperation(resource = Resource.CLUSTER, operation = OperationCode.READ) - public static Result testMultiWordArg( - @CliArgument(name = "arg1" ) String arg1, - @CliArgument(name = "arg2" ) String arg2) { + public static Result testMultiWordArg(@CliArgument(name = "arg1") String arg1, + @CliArgument(name = "arg2") String arg2) { return null; } } @@ -1051,15 +878,16 @@ public class GfshParserJUnitTest { } @Override - public String convertFromText(String value, Class targetType, - String optionContext) { + public String convertFromText(String value, Class targetType, String optionContext) { return value; } @Override public boolean getAllPossibleValues(List completions, - Class targetType, String existingData, String context, - MethodTarget target) { + Class targetType, + String existingData, + String context, + MethodTarget target) { if (context.equals(ARGUMENT1_CONTEXT)) { for (Completion completion : ARGUMENT1_COMPLETIONS) { completions.add(completion); @@ -1078,15 +906,16 @@ public class GfshParserJUnitTest { } public static class AvailabilityCommands implements CommandMarker { + static final String C1_NAME = "C1"; - static final String C1_PROP = C1_NAME+"-available"; + static final String C1_PROP = C1_NAME + "-available"; static final String C1_MSG_UNAVAILABLE = "Requires " + C1_PROP + "=true"; - static final String C1_MSG_AVAILABLE = C1_NAME + " is available."; + static final String C1_MSG_AVAILABLE = C1_NAME + " is available."; static final String C2_NAME = "C2"; - static final String C2_PROP = C2_NAME+"-available"; + static final String C2_PROP = C2_NAME + "-available"; static final String C2_MSG_UNAVAILABLE = CliStrings.AVAILABILITYTARGET_MSG_DEFAULT_UNAVAILABILITY_DESCRIPTION; - static final String C2_MSG_AVAILABLE = C2_NAME + " is available."; + static final String C2_MSG_AVAILABLE = C2_NAME + " is available."; @CliCommand(value = { C1_NAME }) @ResourceOperation(resource = Resource.CLUSTER, operation = OperationCode.READ) http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a8081779/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/JoptOptionParserTest.java ---------------------------------------------------------------------- diff --git a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/JoptOptionParserTest.java b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/JoptOptionParserTest.java index ad82a94..bbe6228 100644 --- a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/JoptOptionParserTest.java +++ b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/JoptOptionParserTest.java @@ -39,7 +39,7 @@ import com.gemstone.gemfire.management.internal.cli.parser.jopt.JoptOptionParser import com.gemstone.gemfire.test.junit.categories.UnitTest; @Category(UnitTest.class) -@RunWith(JUnitParamsRunner.class) +//@RunWith(JUnitParamsRunner.class) public class JoptOptionParserTest { private JoptOptionParser emptyOptionParser; @@ -287,8 +287,8 @@ public class JoptOptionParserTest { assertThat(optionSet.hasOption(this.requiredOption)).isFalse(); } - @Test - @Parameters(method = "exampleInputParameters") +// @Test +// @Parameters(method = "exampleInputParameters") public void parseInputWithExampleInputParametesr(String command, boolean expectException, boolean hasArguments, boolean hasOptions) throws Exception { if (expectException) { assertThatThrownBy(() -> this.exampleOptionParser.parse(command)).isExactlyInstanceOf(CliCommandOptionMissingException.class); http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a8081779/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/CommentSkipHelperTest.java ---------------------------------------------------------------------- diff --git a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/CommentSkipHelperTest.java b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/CommentSkipHelperTest.java new file mode 100644 index 0000000..d9f5f26 --- /dev/null +++ b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/CommentSkipHelperTest.java @@ -0,0 +1,81 @@ +package com.gemstone.gemfire.management.internal.cli.util; + +import static org.assertj.core.api.Assertions.*; + +import org.junit.Before; +import org.junit.Test; + +public class CommentSkipHelperTest { + + private CommentSkipHelper commentSkipHelper; + + @Before + public void setUp() { + this.commentSkipHelper = new CommentSkipHelper(); + } + + @Test + public void nullShouldThrowNullPointerException() { + assertThatThrownBy(() -> this.commentSkipHelper.skipComments(null)).isExactlyInstanceOf(NullPointerException.class); + } + + @Test + public void emptyStringShouldReturnEmptyString() { + assertThat(this.commentSkipHelper.skipComments("")).isEqualTo(""); + } + + @Test + public void stringWithDoubleSlashCommentShouldReturnString() { + String command = "start locator --name=loc1 //"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo(command); + } + + @Test + public void stringWithSlashAsterCommentShouldRemoveComment() { + String command = "start locator /* starting locator */ --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo("start locator --name=loc1"); + } + + @Test + public void stringWithCommentWithoutSpacesShouldRemoveComment() { // TODO: possible bug + String command = "start locator/* starting locator */--name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo("start locator--name=loc1"); + } + + @Test + public void stringWithOpenCommentShouldReturnNull() { // TODO: possible bug + String command = "start locator /* --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isNull(); + } + + @Test + public void stringWithCloseCommentShouldReturnString() { // TODO: possible bug + String command = "start locator */ --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo(command); + } + + @Test + public void stringWithMultiLineCommentShouldRemoveComment() { + String command = "start locator /*\n some \n comment \n */ --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo("start locator --name=loc1"); + } + + @Test + public void stringWithCommentAtEndShouldRemoveComment() { + String command = "start locator --name=loc1 /* comment at end */"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo("start locator --name=loc1 "); + } + + @Test + public void stringWithCommentAtBeginningShouldRemoveComment() { + String command = "/* comment at begin */ start locator --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo(" start locator --name=loc1"); + } + + @Test + public void stringWithInsideOutCommentShouldMisbehave() { // TODO: possible bug + String command = "*/ this is a comment /* start locator --name=loc1"; + assertThat(this.commentSkipHelper.skipComments(command)).isEqualTo("*/ this is a comment this is a comment /* start locator --name=loc1"); + } + +} http://git-wip-us.apache.org/repos/asf/incubator-geode/blob/a8081779/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/OptionJFormatterTest.java ---------------------------------------------------------------------- diff --git a/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/OptionJFormatterTest.java b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/OptionJFormatterTest.java new file mode 100644 index 0000000..1dfc6d1 --- /dev/null +++ b/geode-core/src/test/java/com/gemstone/gemfire/management/internal/cli/util/OptionJFormatterTest.java @@ -0,0 +1,79 @@ +package com.gemstone.gemfire.management.internal.cli.util; + +import static org.assertj.core.api.Assertions.*; +import static org.junit.Assert.*; + +import org.junit.Ignore; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import com.gemstone.gemfire.test.junit.categories.UnitTest; + +@Category(UnitTest.class) +public class OptionJFormatterTest { + + private static final String quote = "\""; + + @Test + public void containsJoptShouldReturnTrueIfCmdHasJ() { + String cmd = "start locator --name=loc1 --J=-Dfoo=bar"; + OptionJFormatter ojf = new OptionJFormatter(); + assertTrue(ojf.containsJopt(cmd)); + } + + @Test + public void containsJoptShouldReturnFalseIfCmdDoesntHaveJ() { + String cmd = "start locator --name=loc1 "; + OptionJFormatter ojf = new OptionJFormatter(); + assertFalse(ojf.containsJopt(cmd)); + } + + @Test + public void containsJoptShouldReturnTrueIfCmdHasMultipleJ() { + String cmd = "start locator --name=loc1 --J=-Dfoo=bar --J=-Dbar=foo"; + OptionJFormatter ojf = new OptionJFormatter(); + assertTrue(ojf.containsJopt(cmd)); + } + + @Test + public void valueWithoutQuotesReturnsWithQuotes() { + String cmd = "start locator --name=loc1 --J=-Dfoo=bar"; + OptionJFormatter ojf = new OptionJFormatter(); + String formattedCmd = ojf.formatCommand(cmd); + + String expected = "start locator --name=loc1 --J=" + quote + "-Dfoo=bar" + quote; + assertThat(formattedCmd).isEqualTo(expected); + } + + @Test + public void valueWithoutQuotesReturnsWithQuotes_2() { + String cmd = "start locator --J=-Dfoo=bar --name=loc1"; + OptionJFormatter ojf = new OptionJFormatter(); + String formattedCmd = ojf.formatCommand(cmd); + + String expected = "start locator --J=" + quote + "-Dfoo=bar" + quote + " --name=loc1"; + assertThat(formattedCmd).isEqualTo(expected); + } + + @Test + public void nullShouldThrowNullPointerException() { + assertThatThrownBy(() -> new OptionJFormatter().formatCommand(null)).isExactlyInstanceOf(NullPointerException.class); + } + + @Test + public void emptyShouldThrowNullPointerException() { + assertThat(new OptionJFormatter().formatCommand("")).isEqualTo(""); + } + + @Ignore + @Test + public void multipleJOptionsShould_something() { + String cmd = "start locator --name=loc1 --J=-Dfoo=bar --J=-Dbar=foo"; + OptionJFormatter ojf = new OptionJFormatter(); + String formattedCmd = ojf.formatCommand(cmd); + + String expected = "start locator --name=loc1 --J=" + quote + "-Dfoo=bar" + quote + " --J=" + quote + "-Dbar=foo" + quote; + assertThat(formattedCmd).isEqualTo(expected); + } + +}