diff --git a/src/test/cli_argument_parser.cpp b/src/test/cli_argument_parser.cpp index 026330c..769d6a5 100644 --- a/src/test/cli_argument_parser.cpp +++ b/src/test/cli_argument_parser.cpp @@ -226,6 +226,48 @@ int main(int argc, char* argv[]) { ASSERT(unknownFlagMixedTestParser.getFlag(std::string("four")).value); delete[] unknownFlagTestParameterList; + + std::vector unknownLongFlagTestFlags; + unknownLongFlagTestFlags.push_back(CLI::Flag('0', "zero", "test flag")); + unknownLongFlagTestFlags.push_back(CLI::Flag('1', "one", "test flag")); + unknownLongFlagTestFlags.push_back(CLI::Flag('2', "two", "test flag")); + unknownLongFlagTestFlags.push_back(CLI::Flag('3', "three","test flag")); + unknownLongFlagTestFlags.push_back(CLI::Flag('4', "four", "test flag")); + unknownLongFlagTestFlags.push_back(CLI::Flag('5', "five", "test flag")); + + std::vector unknownLongFlagTestUnpositionalArguments; + + std::vector unknownLongFlagTestPositionalArguments; + + const char** unknownLongFlagTestParameterList = new const char*[7]; + unknownLongFlagTestParameterList[0] = "test"; + unknownLongFlagTestParameterList[1] = "--a"; + unknownLongFlagTestParameterList[2] = "-1"; + unknownLongFlagTestParameterList[3] = "-2"; + unknownLongFlagTestParameterList[4] = "-3"; + unknownLongFlagTestParameterList[5] = "-4"; + unknownLongFlagTestParameterList[6] = "-5"; + int unknownLongFlagStandaloneTestParameterCount = 2; + + CLI::ArgumentsParser unknownLongFlagStandaloneTestParser = CLI::ArgumentsParser(unknownLongFlagStandaloneTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestUnpositionalArguments, unknownLongFlagTestPositionalArguments); + ASSERT(unknownLongFlagStandaloneTestParser.getFlag('1').isError); + ASSERT(unknownLongFlagStandaloneTestParser.getFlag('1').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(!unknownLongFlagStandaloneTestParser.getFlag('1').value); + ASSERT(unknownLongFlagStandaloneTestParser.getFlag(std::string("four")).isError); + ASSERT(unknownLongFlagStandaloneTestParser.getFlag(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(!unknownLongFlagStandaloneTestParser.getFlag(std::string("four")).value); + + int unknownLongFlagMixedTestParameterCount = 7; + + CLI::ArgumentsParser unknownLongFlagMixedTestParser = CLI::ArgumentsParser(unknownLongFlagMixedTestParameterCount, unknownLongFlagTestParameterList, unknownLongFlagTestFlags, unknownLongFlagTestUnpositionalArguments, unknownLongFlagTestPositionalArguments); + ASSERT(unknownLongFlagMixedTestParser.getFlag('1').isError); + ASSERT(unknownLongFlagMixedTestParser.getFlag('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(unknownLongFlagMixedTestParser.getFlag('1').value); + ASSERT(unknownLongFlagMixedTestParser.getFlag(std::string("four")).isError); + ASSERT(unknownLongFlagMixedTestParser.getFlag(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(unknownLongFlagMixedTestParser.getFlag(std::string("four")).value); + + delete[] unknownLongFlagTestParameterList; std::cout << "Passed unknown flag test." << std::endl; // unknown unpositional argument ################################### @@ -233,12 +275,12 @@ int main(int argc, char* argv[]) { std::vector unknownArgumentTestFlags; std::vector unknownArgumentTestUnpositionalArguments; - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test flag")); - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one", "one", "test flag")); - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two", "two", "test flag")); - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test flag")); - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test flag")); - unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test flag")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one", "one", "test argument")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two", "two", "test argument")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument")); + unknownArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument")); std::vector unknownArgumentTestPositionalArguments; @@ -271,7 +313,280 @@ int main(int argc, char* argv[]) { ASSERT(unknownArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "d"); delete[] unknownArgumentTestParameterList; + + std::vector unknownLongArgumentTestFlags; + + std::vector unknownLongArgumentTestUnpositionalArguments; + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument")); + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one", "one", "test argument")); + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two", "two", "test argument")); + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument")); + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument")); + unknownLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument")); + + std::vector unknownLongArgumentTestPositionalArguments; + + const char** unknownLongArgumentTestParameterList = new const char*[7]; + unknownLongArgumentTestParameterList[0] = "test"; + unknownLongArgumentTestParameterList[1] = "--a=123"; + unknownLongArgumentTestParameterList[2] = "-1a"; + unknownLongArgumentTestParameterList[3] = "-2b"; + unknownLongArgumentTestParameterList[4] = "-3c"; + unknownLongArgumentTestParameterList[5] = "-4d"; + unknownLongArgumentTestParameterList[6] = "-5e"; + int unknownLongArgumentStandaloneTestParameterCount = 2; + + CLI::ArgumentsParser unknownLongArgumentStandaloneTestParser = CLI::ArgumentsParser(unknownLongArgumentStandaloneTestParameterCount, unknownLongArgumentTestParameterList, unknownLongArgumentTestFlags, unknownLongArgumentTestUnpositionalArguments, unknownLongArgumentTestPositionalArguments); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').isError); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument('1').value == ""); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(unknownLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == ""); + + int unknownLongArgumentMixedTestParameterCount = 7; + + CLI::ArgumentsParser unknownLongArgumentMixedTestParser = CLI::ArgumentsParser(unknownLongArgumentMixedTestParameterCount, unknownLongArgumentTestParameterList, unknownLongArgumentTestFlags, unknownLongArgumentTestUnpositionalArguments, unknownLongArgumentTestPositionalArguments); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').isError); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument('1').value == "a"); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(unknownLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == "d"); + + delete[] unknownLongArgumentTestParameterList; std::cout << "Passed unknown unpositional argument test." << std::endl; + // incomplete unpositional argument ################################### + + std::vector incompleteArgumentTestFlags; + + std::vector incompleteArgumentTestUnpositionalArguments; + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument")); + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one", "one", "test argument")); + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two", "two", "test argument")); + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument")); + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument")); + incompleteArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument")); + + std::vector incompleteArgumentTestPositionalArguments; + + const char** incompleteArgumentTestParameterList = new const char*[6]; + incompleteArgumentTestParameterList[0] = "test"; + incompleteArgumentTestParameterList[1] = "-1"; + incompleteArgumentTestParameterList[2] = "-2b"; + incompleteArgumentTestParameterList[3] = "-3c"; + incompleteArgumentTestParameterList[4] = "-4"; + incompleteArgumentTestParameterList[5] = "-5e"; + int incompleteArgumentStandaloneTestParameterCount = 2; + + CLI::ArgumentsParser incompleteArgumentStandaloneTestParser = CLI::ArgumentsParser(incompleteArgumentStandaloneTestParameterCount, incompleteArgumentTestParameterList, incompleteArgumentTestFlags, incompleteArgumentTestUnpositionalArguments, incompleteArgumentTestPositionalArguments); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').isError); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument('1').value == ""); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(incompleteArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == ""); + + int incompleteArgumentMixedTestParameterCount = 6; + + CLI::ArgumentsParser incompleteArgumentMixedTestParser = CLI::ArgumentsParser(incompleteArgumentMixedTestParameterCount, incompleteArgumentTestParameterList, incompleteArgumentTestFlags, incompleteArgumentTestUnpositionalArguments, incompleteArgumentTestPositionalArguments); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').isError); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('1').value == ""); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == ""); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').isError); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteArgumentMixedTestParser.getUnpositionalArgument('5').value == "e"); + + delete[] incompleteArgumentTestParameterList; + + std::vector incompleteLongArgumentTestFlags; + + std::vector incompleteLongArgumentTestUnpositionalArguments; + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('0', "zero", "zero", "test argument")); + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('1', "one", "one", "test argument")); + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('2', "two", "two", "test argument")); + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('3', "three","three","test argument")); + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('4', "four", "four", "test argument")); + incompleteLongArgumentTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('5', "five", "five", "test argument")); + + std::vector incompleteLongArgumentTestPositionalArguments; + + const char** incompleteLongArgumentTestParameterList = new const char*[8]; + incompleteLongArgumentTestParameterList[0] = "test"; + incompleteLongArgumentTestParameterList[1] = "--one"; + incompleteLongArgumentTestParameterList[2] = "--two"; + incompleteLongArgumentTestParameterList[3] = "b"; + incompleteLongArgumentTestParameterList[4] = "-3c"; + incompleteLongArgumentTestParameterList[5] = "positional_arg"; + incompleteLongArgumentTestParameterList[6] = "--four"; + incompleteLongArgumentTestParameterList[7] = "--five=e"; + int incompleteLongArgumentStandaloneTestParameterCount = 2; + + CLI::ArgumentsParser incompleteLongArgumentStandaloneTestParser = CLI::ArgumentsParser(incompleteLongArgumentStandaloneTestParameterCount, incompleteLongArgumentTestParameterList, incompleteLongArgumentTestFlags, incompleteLongArgumentTestUnpositionalArguments, incompleteLongArgumentTestPositionalArguments); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').isError); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument('1').value == ""); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(incompleteLongArgumentStandaloneTestParser.getUnpositionalArgument(std::string("four")).value == ""); + + int incompleteLongArgumentMixedTestParameterCount = 8; + + CLI::ArgumentsParser incompleteLongArgumentMixedTestParser = CLI::ArgumentsParser(incompleteLongArgumentMixedTestParameterCount, incompleteLongArgumentTestParameterList, incompleteLongArgumentTestFlags, incompleteLongArgumentTestUnpositionalArguments, incompleteLongArgumentTestPositionalArguments); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').isError); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('1').value == ""); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').isError); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('2').value == "b"); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).isError); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument(std::string("four")).value == ""); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').isError); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(incompleteLongArgumentMixedTestParser.getUnpositionalArgument('5').value == "e"); + + delete[] incompleteLongArgumentTestParameterList; + std::cout << "Passed incomplete unpositional argument test." << std::endl; + + // too few positional arguments + + std::vector tooFewArgumentsTestFlags; + tooFewArgumentsTestFlags.push_back(CLI::Flag('a', "aaaaa", "test flag")); + + std::vector tooFewArgumentsTestUnpositionalArguments; + tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('b', "bbbbb", "b", "test argument")); + tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('c', "ccccc", "c", "test argument")); + tooFewArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('d', "ddddd", "d", "test argument")); + + std::vector tooFewArgumentsTestPositionalArguments; + tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument0", "test argument")); + tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument1", "test argument")); + tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument2", "test argument")); + tooFewArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument3", "test argument")); + + const char** tooFewArgumentsTestParameterList = new const char*[10]; + tooFewArgumentsTestParameterList[0] = "test"; + tooFewArgumentsTestParameterList[1] = "positional_arg_0"; + tooFewArgumentsTestParameterList[2] = "-a";// + tooFewArgumentsTestParameterList[3] = "-b"; + tooFewArgumentsTestParameterList[4] = "1"; + tooFewArgumentsTestParameterList[5] = "-c5"; + tooFewArgumentsTestParameterList[6] = "positional_arg_1"; + tooFewArgumentsTestParameterList[7] = "--ddddd"; + tooFewArgumentsTestParameterList[8] = "ddd"; + tooFewArgumentsTestParameterList[9] = "positional_arg_2"; + + int tooFewArgumentsStandaloneTestParameterCount = 2; + CLI::ArgumentsParser tooFewArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooFewArgumentsStandaloneTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestUnpositionalArguments, tooFewArgumentsTestPositionalArguments); + + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).isError); + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(0).value == "positional_arg_0"); + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).isError); + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooFewArgumentsStandaloneTestParser.getPositionalArgument(1).value == ""); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').isError); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('b').value == ""); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').isError); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('c').value == ""); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').isError); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooFewArgumentsStandaloneTestParser.getUnpositionalArgument('d').value == ""); + + int tooFewArgumentsMixedTestParameterCount = 10; + CLI::ArgumentsParser tooFewArgumentsMixedTestParser = CLI::ArgumentsParser(tooFewArgumentsMixedTestParameterCount, tooFewArgumentsTestParameterList, tooFewArgumentsTestFlags, tooFewArgumentsTestUnpositionalArguments, tooFewArgumentsTestPositionalArguments); + + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).isError); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(0).value == "positional_arg_0"); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).isError); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(1).value == "positional_arg_1"); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).isError); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(2).value == "positional_arg_2"); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).isError); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooFewArgumentsMixedTestParser.getPositionalArgument(3).value == ""); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').isError); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('b').value == "1"); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').isError); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('c').value == "5"); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').isError); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooFewArgumentsMixedTestParser.getUnpositionalArgument('d').value == "ddd"); + + delete[] tooFewArgumentsTestParameterList; + std::cout << "Passed too few positional arguments test." << std::endl; + + // too many positional arguments + + std::vector tooManyArgumentsTestFlags; + tooManyArgumentsTestFlags.push_back(CLI::Flag('a', "aaaaa", "test flag")); + + std::vector tooManyArgumentsTestUnpositionalArguments; + tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('b', "bbbbb", "b", "test argument")); + tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('c', "ccccc", "c", "test argument")); + tooManyArgumentsTestUnpositionalArguments.push_back(CLI::UnpositionalArgument('d', "ddddd", "d", "test argument")); + + std::vector tooManyArgumentsTestPositionalArguments; + tooManyArgumentsTestPositionalArguments.push_back(CLI::PositionalArgument("argument0", "test argument")); + + const char** tooManyArgumentsTestParameterList = new const char*[10]; + tooManyArgumentsTestParameterList[0] = "test"; + tooManyArgumentsTestParameterList[1] = "positional_arg_0"; + tooManyArgumentsTestParameterList[2] = "positional_arg_1"; + tooManyArgumentsTestParameterList[3] = "-a";// + tooManyArgumentsTestParameterList[4] = "-b"; + tooManyArgumentsTestParameterList[5] = "1"; + tooManyArgumentsTestParameterList[6] = "-c5"; + tooManyArgumentsTestParameterList[7] = "--ddddd"; + tooManyArgumentsTestParameterList[8] = "ddd"; + tooManyArgumentsTestParameterList[9] = "positional_arg_2"; + + int tooManyArgumentsStandaloneTestParameterCount = 3; + CLI::ArgumentsParser tooManyArgumentsStandaloneTestParser = CLI::ArgumentsParser(tooManyArgumentsStandaloneTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestUnpositionalArguments, tooManyArgumentsTestPositionalArguments); + + ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).isError); + ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooManyArgumentsStandaloneTestParser.getPositionalArgument(0).value == "positional_arg_0"); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').isError); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('b').value == ""); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').isError); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('c').value == ""); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').isError); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::NOT_PRESENT); + ASSERT(tooManyArgumentsStandaloneTestParser.getUnpositionalArgument('d').value == ""); + + int tooManyArgumentsMixedTestParameterCount = 10; + CLI::ArgumentsParser tooManyArgumentsMixedTestParser = CLI::ArgumentsParser(tooManyArgumentsMixedTestParameterCount, tooManyArgumentsTestParameterList, tooManyArgumentsTestFlags, tooManyArgumentsTestUnpositionalArguments, tooManyArgumentsTestPositionalArguments); + + ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).isError); + ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooManyArgumentsMixedTestParser.getPositionalArgument(0).value == "positional_arg_0"); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').isError); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('b').value == "1"); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').isError); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('c').value == "5"); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').isError); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').errorCode == ErrorCodes::WRONG_USAGE); + ASSERT(tooManyArgumentsMixedTestParser.getUnpositionalArgument('d').value == "ddd"); + + delete[] tooManyArgumentsTestParameterList; + std::cout << "Passed too many positional arguments test." << std::endl; + return 0; }