From eef2da1547ba10b61c232a0df19374c5efbb7597 Mon Sep 17 00:00:00 2001 From: "Taylor C. Richberger" Date: Tue, 10 May 2016 16:40:57 -0600 Subject: rename everything --- test.cxx | 74 ++++++++++++++++++++++++++++++++-------------------------------- 1 file changed, 37 insertions(+), 37 deletions(-) (limited to 'test.cxx') diff --git a/test.cxx b/test.cxx index c5ab1b3..4d4e6ef 100644 --- a/test.cxx +++ b/test.cxx @@ -52,9 +52,9 @@ TEST_CASE("Boolean flags work as expected, with clustering", "[args]") TEST_CASE("Count flag works as expected", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::Counter foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); - args::Counter bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}, 7); - args::Counter baz(parser, "BAZ", "test flag", args::Matcher{'z', "baz"}, 7); + args::CounterFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::CounterFlag bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}, 7); + args::CounterFlag baz(parser, "BAZ", "test flag", args::Matcher{'z', "baz"}, 7); parser.ParseArgs(std::vector{"--foo", "-fb", "--bar", "-b", "-f", "--foo"}); REQUIRE(foo); REQUIRE(bar); @@ -67,10 +67,10 @@ TEST_CASE("Count flag works as expected", "[args]") TEST_CASE("Argument flags work as expected, with clustering", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::ValueFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); args::Flag bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}); - args::ArgFlag baz(parser, "BAZ", "test flag", args::Matcher{'a', "baz"}); - args::ArgFlag bim(parser, "BAZ", "test flag", args::Matcher{'B', "bim"}); + args::ValueFlag baz(parser, "BAZ", "test flag", args::Matcher{'a', "baz"}); + args::ValueFlag bim(parser, "BAZ", "test flag", args::Matcher{'B', "bim"}); args::Flag bix(parser, "BAZ", "test flag", args::Matcher{'x', "bix"}); parser.ParseArgs(std::vector{"-bftest", "--baz=7.555e2", "--bim", "c"}); REQUIRE(foo); @@ -93,10 +93,10 @@ TEST_CASE("Passing an argument to a non-argument flag throws an error", "[args]" TEST_CASE("Unified argument lists for match work", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::ValueFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); args::Flag bar(parser, "BAR", "test flag", args::Matcher{"bar", 'b'}); - args::ArgFlag baz(parser, "BAZ", "test flag", args::Matcher{'a', "baz"}); - args::ArgFlag bim(parser, "BAZ", "test flag", args::Matcher{'B', "bim"}); + args::ValueFlag baz(parser, "BAZ", "test flag", args::Matcher{'a', "baz"}); + args::ValueFlag bim(parser, "BAZ", "test flag", args::Matcher{'B', "bim"}); args::Flag bix(parser, "BAZ", "test flag", args::Matcher{"bix"}); parser.ParseArgs(std::vector{"-bftest", "--baz=7.555e2", "--bim", "c"}); REQUIRE(foo); @@ -112,7 +112,7 @@ TEST_CASE("Unified argument lists for match work", "[args]") TEST_CASE("Get can be assigned to for non-reference types", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::ValueFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); parser.ParseArgs(std::vector{"--foo=test"}); REQUIRE(foo); REQUIRE(args::get(foo) == "test"); @@ -123,7 +123,7 @@ TEST_CASE("Get can be assigned to for non-reference types", "[args]") TEST_CASE("Invalid argument parsing throws parsing exceptions", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::ValueFlag foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); REQUIRE_THROWS_AS(parser.ParseArgs(std::vector{"--foo=7.5"}), args::ParseError); REQUIRE_THROWS_AS(parser.ParseArgs(std::vector{"--foo", "7a"}), args::ParseError); REQUIRE_THROWS_AS(parser.ParseArgs(std::vector{"--foo", "7e4"}), args::ParseError); @@ -132,7 +132,7 @@ TEST_CASE("Invalid argument parsing throws parsing exceptions", "[args]") TEST_CASE("Argument flag lists work as expected", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlagList foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); + args::ValueFlagList foo(parser, "FOO", "test flag", args::Matcher{'f', "foo"}); parser.ParseArgs(std::vector{"--foo=7", "-f2", "-f", "9", "--foo", "42"}); REQUIRE((args::get(foo) == std::vector{7, 2, 9, 42})); } @@ -140,9 +140,9 @@ TEST_CASE("Argument flag lists work as expected", "[args]") TEST_CASE("Positional arguments and positional argument lists work as expected", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::PosArg foo(parser, "FOO", "test flag"); - args::PosArg bar(parser, "BAR", "test flag"); - args::PosArgList baz(parser, "BAZ", "test flag"); + args::Positional foo(parser, "FOO", "test flag"); + args::Positional bar(parser, "BAR", "test flag"); + args::PositionalList baz(parser, "BAZ", "test flag"); parser.ParseArgs(std::vector{"this is a test flag", "0", "a", "b", "c", "x", "y", "z"}); REQUIRE(foo); REQUIRE((args::get(foo) == "this is a test flag")); @@ -155,9 +155,9 @@ TEST_CASE("Positional arguments and positional argument lists work as expected", TEST_CASE("Positionals that are unspecified evaluate false", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::PosArg foo(parser, "FOO", "test flag"); - args::PosArg bar(parser, "BAR", "test flag"); - args::PosArgList baz(parser, "BAZ", "test flag"); + args::Positional foo(parser, "FOO", "test flag"); + args::Positional bar(parser, "BAR", "test flag"); + args::PositionalList baz(parser, "BAZ", "test flag"); parser.ParseArgs(std::vector{"this is a test flag again"}); REQUIRE(foo); REQUIRE((args::get(foo) == "this is a test flag again")); @@ -168,8 +168,8 @@ TEST_CASE("Positionals that are unspecified evaluate false", "[args]") TEST_CASE("Additional positionals throw an exception", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::PosArg foo(parser, "FOO", "test flag"); - args::PosArg bar(parser, "BAR", "test flag"); + args::Positional foo(parser, "FOO", "test flag"); + args::Positional bar(parser, "BAR", "test flag"); REQUIRE_THROWS_AS(parser.ParseArgs(std::vector{"this is a test flag again", "1", "this has no positional available"}), args::ParseError); } @@ -243,13 +243,13 @@ TEST_CASE("Custom types work", "[args]") { { args::ArgumentParser parser("This is a test program."); - args::PosArg> ints(parser, "INTS", "This takes a pair of integers."); - args::PosArg, DoublesReader> doubles(parser, "DOUBLES", "This takes a pair of doubles."); + args::Positional> ints(parser, "INTS", "This takes a pair of integers."); + args::Positional, DoublesReader> doubles(parser, "DOUBLES", "This takes a pair of doubles."); REQUIRE_THROWS_AS(parser.ParseArgs(std::vector{"1.2,2", "3.8,4"}), args::ParseError); } args::ArgumentParser parser("This is a test program."); - args::PosArg> ints(parser, "INTS", "This takes a pair of integers."); - args::PosArg, DoublesReader> doubles(parser, "DOUBLES", "This takes a pair of doubles."); + args::Positional> ints(parser, "INTS", "This takes a pair of integers."); + args::Positional, DoublesReader> doubles(parser, "DOUBLES", "This takes a pair of doubles."); parser.ParseArgs(std::vector{"1,2", "3.8,4"}); REQUIRE(std::get<0>(args::get(ints)) == 1); REQUIRE(std::get<1>(args::get(ints)) == 2); @@ -263,10 +263,10 @@ TEST_CASE("Custom parser prefixes (dd-style)", "[args]") parser.LongPrefix(""); parser.LongSeparator("="); args::HelpFlag help(parser, "HELP", "Show this help menu.", args::Matcher({"help"})); - args::ArgFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); - args::ArgFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); - args::ArgFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); - args::ArgFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); + args::ValueFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); + args::ValueFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); + args::ValueFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); + args::ValueFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); parser.ParseArgs(std::vector{"skip=8", "if=/dev/null"}); REQUIRE_FALSE(bs); REQUIRE(args::get(bs) == 512); @@ -283,10 +283,10 @@ TEST_CASE("Custom parser prefixes (Some Windows styles)", "[args]") parser.LongPrefix("/"); parser.LongSeparator(":"); args::HelpFlag help(parser, "HELP", "Show this help menu.", args::Matcher({"help"})); - args::ArgFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); - args::ArgFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); - args::ArgFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); - args::ArgFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); + args::ValueFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); + args::ValueFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); + args::ValueFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); + args::ValueFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); parser.ParseArgs(std::vector{"/skip:8", "/if:/dev/null"}); REQUIRE_FALSE(bs); REQUIRE(args::get(bs) == 512); @@ -302,10 +302,10 @@ TEST_CASE("Help menu can be grabbed as a string, passed into a stream, or by usi std::ostream null(nullptr); args::ArgumentParser parser("This command likes to break your disks"); args::HelpFlag help(parser, "HELP", "Show this help menu.", args::Matcher({"help"})); - args::ArgFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); - args::ArgFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); - args::ArgFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); - args::ArgFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); + args::ValueFlag bs(parser, "BYTES", "Block size", args::Matcher({"bs"}), 512); + args::ValueFlag skip(parser, "BYTES", "Bytes to skip", args::Matcher({"skip"}), 0); + args::ValueFlag input(parser, "BLOCK SIZE", "Block size", args::Matcher({"if"})); + args::ValueFlag output(parser, "BLOCK SIZE", "Block size", args::Matcher({"of"})); parser.ParseArgs(std::vector{"--skip=8", "--if=/dev/null"}); null << parser.Help(); parser.Help(null); @@ -315,7 +315,7 @@ TEST_CASE("Help menu can be grabbed as a string, passed into a stream, or by usi TEST_CASE("Required argument separation being violated throws an error", "[args]") { args::ArgumentParser parser("This is a test program.", "This goes after the options."); - args::ArgFlag bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}); + args::ValueFlag bar(parser, "BAR", "test flag", args::Matcher{'b', "bar"}); REQUIRE_NOTHROW(parser.ParseArgs(std::vector{"-btest"})); REQUIRE_NOTHROW(parser.ParseArgs(std::vector{"--bar=test"})); REQUIRE_NOTHROW(parser.ParseArgs(std::vector{"-b", "test"})); -- cgit v1.2.1