KeqingMoe/argparse
1
0
Fork 0
mirror of https://github.com/KeqingMoe/argparse.git synced 2025-07-04 15:14:39 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Closes #53

Browse Source
This commit is contained in:
Pranav Srinivas Kumar 2019-11-21 09:08:49 -06:00
parent c95835acf8
commit f9ab33d1a6
17 changed files with 6017 additions and 15990 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
test/CMakeLists.txt
View File

@ -25,8 +25,6 @@ endif()
# ARGPARSE executable
file(GLOB ARGPARSE_TEST_SOURCES
"*.cpp"
"*.hpp"
"../include/argparse.hpp"
)
ADD_EXECUTABLE(ARGPARSE ${ARGPARSE_TEST_SOURCES})
INCLUDE_DIRECTORIES("../include" ".")

15883
test/catch.hpp
View File

File diff suppressed because it is too large Load Diff

5941
test/doctest.hpp Normal file
View File

File diff suppressed because it is too large Load Diff

18
test/main.cpp
View File

@ -1,16 +1,2 @@
#define CATCH_CONFIG_MAIN
#include <iostream>
#include <argparse.hpp>
#include <test_help.hpp>
#include <test_parse_args.hpp>
#include <test_positional_arguments.hpp>
#include <test_optional_arguments.hpp>
#include <test_compound_arguments.hpp>
#include <test_actions.hpp>
#include <test_container_arguments.hpp>
#include <test_parent_parsers.hpp>
#include <test_invalid_arguments.hpp>
#include <test_negative_numbers.hpp>
#include <test_required_arguments.hpp>
#include <test_value_semantics.hpp>
#include <test_issue_37.hpp>
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include <doctest.hpp>

15
test/test_actions.hpp → test/test_actions.cpp
View File

@ -1,9 +1,8 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
#include <string_view>
TEST_CASE("Users can use default value inside actions", "[actions]") {
DOCTEST_TEST_CASE("Users can use default value inside actions [actions]") {
argparse::ArgumentParser program("test");
program.add_argument("input")
.default_value("bar")
@ -19,7 +18,7 @@ TEST_CASE("Users can use default value inside actions", "[actions]") {
REQUIRE(program.get("input") == "bar");
}
TEST_CASE("Users can add actions that return nothing", "[actions]") {
DOCTEST_TEST_CASE("Users can add actions that return nothing [actions]") {
argparse::ArgumentParser program("test");
bool pressed = false;
auto &arg = program.add_argument("button").action(
@ -27,12 +26,12 @@ TEST_CASE("Users can add actions that return nothing", "[actions]") {
REQUIRE_FALSE(pressed);
SECTION("action performed") {
DOCTEST_SUBCASE("action performed") {
program.parse_args({"test", "ignored"});
REQUIRE(pressed);
}
SECTION("action performed and nothing overrides the default value") {
DOCTEST_SUBCASE("action performed and nothing overrides the default value") {
arg.default_value(42);
program.parse_args({"test", "ignored"});
@ -67,7 +66,7 @@ public:
}
};
TEST_CASE("Users can bind arguments to actions", "[actions]") {
DOCTEST_TEST_CASE("Users can bind arguments to actions [actions]") {
argparse::ArgumentParser program("test");
GIVEN("an default initialized object bounded by reference") {
@ -120,7 +119,7 @@ TEST_CASE("Users can bind arguments to actions", "[actions]") {
}
}
TEST_CASE("Users can use actions on remaining arguments", "[actions]") {
DOCTEST_TEST_CASE("Users can use actions on remaining arguments [actions]") {
argparse::ArgumentParser program("sum");
int result = 0;

13
test/test_compound_arguments.hpp → test/test_compound_arguments.cpp
View File

@ -1,9 +1,8 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
#include <test_utility.hpp>
TEST_CASE("Parse compound toggle arguments with implicit values", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse compound toggle arguments with implicit values [compound_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("-a")
.default_value(false)
@ -23,7 +22,7 @@ TEST_CASE("Parse compound toggle arguments with implicit values", "[compound_arg
REQUIRE(program.get<bool>("-x") == true);
}
TEST_CASE("Parse compound toggle arguments with implicit values and nargs", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse compound toggle arguments with implicit values and nargs [compound_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("-a")
.default_value(false)
@ -55,7 +54,7 @@ TEST_CASE("Parse compound toggle arguments with implicit values and nargs", "[co
REQUIRE(input_files[2] == "c.txt");
}
TEST_CASE("Parse compound toggle arguments with implicit values and nargs and other positional arguments", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse compound toggle arguments with implicit values and nargs and other positional arguments [compound_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("numbers")
@ -80,7 +79,7 @@ TEST_CASE("Parse compound toggle arguments with implicit values and nargs and ot
REQUIRE_THROWS(program.parse_args({ "./test.exe", "1", "-abc", "3.14", "2.718", "2", "--input_files", "a.txt", "b.txt", "c.txt", "3" }));
}
TEST_CASE("Parse out-of-order compound arguments", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse out-of-order compound arguments [compound_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("-a")
@ -105,7 +104,7 @@ TEST_CASE("Parse out-of-order compound arguments", "[compound_arguments]") {
REQUIRE(program["-c"] == std::vector<float>{3.14f, 2.718f});
}
TEST_CASE("Parse out-of-order compound arguments. Second variation", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse out-of-order compound arguments. Second variation [compound_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("-a")

11
test/test_container_arguments.hpp → test/test_container_arguments.cpp
View File

@ -1,9 +1,8 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
#include <test_utility.hpp>
TEST_CASE("Parse vector of arguments", "[vector]") {
DOCTEST_TEST_CASE("Parse vector of arguments [vector]") {
argparse::ArgumentParser program("test");
program.add_argument("input")
.nargs(2);
@ -16,7 +15,7 @@ TEST_CASE("Parse vector of arguments", "[vector]") {
REQUIRE(inputs[1] == "thrust_profile.csv");
}
TEST_CASE("Parse list of arguments", "[vector]") {
DOCTEST_TEST_CASE("Parse list of arguments [vector]") {
argparse::ArgumentParser program("test");
program.add_argument("input")
.nargs(2);
@ -29,7 +28,7 @@ TEST_CASE("Parse list of arguments", "[vector]") {
REQUIRE(testutility::get_from_list(inputs, 1) == "thrust_profile.csv");
}
TEST_CASE("Parse list of arguments with default values", "[vector]") {
DOCTEST_TEST_CASE("Parse list of arguments with default values [vector]") {
argparse::ArgumentParser program("test");
program.add_argument("--input")
.default_value(std::list<int>{1, 2, 3, 4, 5})
@ -47,7 +46,7 @@ TEST_CASE("Parse list of arguments with default values", "[vector]") {
REQUIRE(program["--input"] == std::list<int>{1, 2, 3, 4, 5});
}
TEST_CASE("Parse list of arguments and save in an object", "[vector]") {
DOCTEST_TEST_CASE("Parse list of arguments and save in an object [vector]") {
struct ConfigManager {
std::vector<std::string> files;

5
test/test_help.hpp → test/test_help.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Users can format help message", "[help]") {
DOCTEST_TEST_CASE("Users can format help message [help]") {
argparse::ArgumentParser program("test");
program.add_argument("input")
.help("positional input");

5
test/test_invalid_arguments.hpp → test/test_invalid_arguments.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Parse unknown optional argument", "[compound_arguments]") {
DOCTEST_TEST_CASE("Parse unknown optional argument [compound_arguments]") {
argparse::ArgumentParser bfm("bfm");

5
test/test_issue_37.hpp → test/test_issue_37.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Issues with implicit values #37", "[implicit_values]") {
DOCTEST_TEST_CASE("Issues with implicit values #37 [implicit_values]") {
argparse::ArgumentParser m_bfm("test");
m_bfm.add_argument("-l", "--load")
.help("load a VMM into the kernel");

15
test/test_negative_numbers.hpp → test/test_negative_numbers.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Parse negative integer", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse negative integer [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")
@ -17,7 +16,7 @@ TEST_CASE("Parse negative integer", "[positional_arguments]") {
REQUIRE(program.get<int>("number") == -1);
}
TEST_CASE("Parse negative integers into a vector", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse negative integers into a vector [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")
@ -33,7 +32,7 @@ TEST_CASE("Parse negative integers into a vector", "[positional_arguments]") {
REQUIRE(program["number"] == std::vector<int>{-1, -2, 3});
}
TEST_CASE("Parse negative float", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse negative float [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")
@ -48,7 +47,7 @@ TEST_CASE("Parse negative float", "[positional_arguments]") {
REQUIRE(program.get<float>("number") == -1.0);
}
TEST_CASE("Parse negative floats into a vector", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse negative floats into a vector [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")
@ -64,7 +63,7 @@ TEST_CASE("Parse negative floats into a vector", "[positional_arguments]") {
REQUIRE(program["number"] == std::vector<double>{-1.001, -2.002, 3.003});
}
TEST_CASE("Parse numbers in E notation", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse numbers in E notation [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")
@ -79,7 +78,7 @@ TEST_CASE("Parse numbers in E notation", "[positional_arguments]") {
REQUIRE(program.get<double>("number") == -1200.0);
}
TEST_CASE("Parse numbers in E notation (capital E)", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse numbers in E notation (capital E) [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")

13
test/test_optional_arguments.hpp → test/test_optional_arguments.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Parse toggle arguments with default value", "[optional_arguments]") {
DOCTEST_TEST_CASE("Parse toggle arguments with default value [optional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--verbose", "-v")
.default_value(false)
@ -13,7 +12,7 @@ TEST_CASE("Parse toggle arguments with default value", "[optional_arguments]") {
REQUIRE(program["--verbose"] == false);
}
TEST_CASE("Parse toggle arguments with implicit value", "[optional_arguments]") {
DOCTEST_TEST_CASE("Parse toggle arguments with implicit value [optional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--verbose")
.default_value(false)
@ -25,7 +24,7 @@ TEST_CASE("Parse toggle arguments with implicit value", "[optional_arguments]")
REQUIRE(program["--verbose"] != false);
}
TEST_CASE("Parse multiple toggle arguments with implicit values", "[optional_arguments]") {
DOCTEST_TEST_CASE("Parse multiple toggle arguments with implicit values [optional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("-a")
.default_value(false)
@ -45,7 +44,7 @@ TEST_CASE("Parse multiple toggle arguments with implicit values", "[optional_arg
REQUIRE(program.get<bool>("-x") == true);
}
TEST_CASE("Parse optional arguments of many values", "[optional_arguments]") {
DOCTEST_TEST_CASE("Parse optional arguments of many values [optional_arguments]") {
GIVEN("a program that accepts an optional argument of many values") {
argparse::ArgumentParser program("test");
program.add_argument("-i").remaining().action(
@ -74,7 +73,7 @@ TEST_CASE("Parse optional arguments of many values", "[optional_arguments]") {
}
}
TEST_CASE("Parse arguments of different types", "[optional_arguments]") {
DOCTEST_TEST_CASE("Parse arguments of different types [optional_arguments]") {
using namespace std::literals;
argparse::ArgumentParser program("test");

7
test/test_parent_parsers.hpp → test/test_parent_parsers.cpp
View File

@ -1,8 +1,7 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Add parent parsers", "[parent_parsers]") {
DOCTEST_TEST_CASE("Add parent parsers [parent_parsers]") {
argparse::ArgumentParser parent_parser("main");
parent_parser.add_argument("--verbose")
.default_value(false)
@ -15,7 +14,7 @@ TEST_CASE("Add parent parsers", "[parent_parsers]") {
REQUIRE(parent_parser["--verbose"] == false);
}
TEST_CASE("Add parent to multiple parent parsers", "[parent_parsers]") {
DOCTEST_TEST_CASE("Add parent to multiple parent parsers [parent_parsers]") {
argparse::ArgumentParser parent_parser("main");
parent_parser.add_argument("--parent")
.default_value(0)

31
test/test_parse_args.hpp → test/test_parse_args.cpp
View File

@ -1,15 +1,14 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Parse a string argument with value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a string argument with value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--config");
program.parse_args({ "test", "--config", "config.yml"});
REQUIRE(program.get("--config") == "config.yml");
}
TEST_CASE("Parse a string argument with default value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a string argument with default value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--config")
.default_value(std::string("foo.yml"));
@ -17,7 +16,7 @@ TEST_CASE("Parse a string argument with default value", "[parse_args]") {
REQUIRE(program.get("--config") == "foo.yml");
}
TEST_CASE("Parse an int argument with value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse an int argument with value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--count")
.action([](const std::string& value) { return std::stoi(value); });
@ -25,7 +24,7 @@ TEST_CASE("Parse an int argument with value", "[parse_args]") {
REQUIRE(program.get<int>("--count") == 5);
}
TEST_CASE("Parse an int argument with default value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse an int argument with default value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--count")
.default_value(2)
@ -34,7 +33,7 @@ TEST_CASE("Parse an int argument with default value", "[parse_args]") {
REQUIRE(program.get<int>("--count") == 2);
}
TEST_CASE("Parse a float argument with value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a float argument with value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.action([](const std::string& value) { return std::stof(value); });
@ -42,7 +41,7 @@ TEST_CASE("Parse a float argument with value", "[parse_args]") {
REQUIRE(program.get<float>("--ratio") == 5.6645f);
}
TEST_CASE("Parse a float argument with default value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a float argument with default value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.default_value(3.14f)
@ -51,7 +50,7 @@ TEST_CASE("Parse a float argument with default value", "[parse_args]") {
REQUIRE(program.get<float>("--ratio") == 3.14f);
}
TEST_CASE("Parse a double argument with value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a double argument with value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.action([](const std::string& value) { return std::stod(value); });
@ -59,7 +58,7 @@ TEST_CASE("Parse a double argument with value", "[parse_args]") {
REQUIRE(program.get<double>("--ratio") == 5.6645);
}
TEST_CASE("Parse a double argument with default value", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a double argument with default value [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--ratio")
.default_value(3.14)
@ -68,7 +67,7 @@ TEST_CASE("Parse a double argument with default value", "[parse_args]") {
REQUIRE(program.get<double>("--ratio") == 3.14);
}
TEST_CASE("Parse a vector of integer arguments", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of integer arguments [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--vector")
.nargs(5)
@ -83,7 +82,7 @@ TEST_CASE("Parse a vector of integer arguments", "[parse_args]") {
REQUIRE(vector[4] == 5);
}
TEST_CASE("Parse a vector of float arguments", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of float arguments [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--vector")
.nargs(5)
@ -98,7 +97,7 @@ TEST_CASE("Parse a vector of float arguments", "[parse_args]") {
REQUIRE(vector[4] == 5.5f);
}
TEST_CASE("Parse a vector of double arguments", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of double arguments [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--vector")
.nargs(5)
@ -113,7 +112,7 @@ TEST_CASE("Parse a vector of double arguments", "[parse_args]") {
REQUIRE(vector[4] == 5.5);
}
TEST_CASE("Parse a vector of string arguments", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of string arguments [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--vector")
.nargs(5)
@ -128,7 +127,7 @@ TEST_CASE("Parse a vector of string arguments", "[parse_args]") {
REQUIRE(vector[4] == "mno");
}
TEST_CASE("Parse a vector of character arguments", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of character arguments [parse_args]") {
argparse::ArgumentParser program("test");
program.add_argument("--vector")
.nargs(5)
@ -143,7 +142,7 @@ TEST_CASE("Parse a vector of character arguments", "[parse_args]") {
REQUIRE(vector[4] == 'e');
}
TEST_CASE("Parse a vector of string arguments and construct objects", "[parse_args]") {
DOCTEST_TEST_CASE("Parse a vector of string arguments and construct objects [parse_args]") {
class Foo {
public:

19
test/test_positional_arguments.hpp → test/test_positional_arguments.cpp
View File

@ -1,8 +1,8 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
#include <cmath>
TEST_CASE("Parse positional arguments", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse positional arguments [positional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("input");
program.add_argument("output");
@ -11,7 +11,7 @@ TEST_CASE("Parse positional arguments", "[positional_arguments]") {
REQUIRE(program.get("output") == "thrust_profile.csv");
}
TEST_CASE("Parse positional arguments with fixed nargs", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse positional arguments with fixed nargs [positional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("input");
program.add_argument("output").nargs(2);
@ -23,7 +23,7 @@ TEST_CASE("Parse positional arguments with fixed nargs", "[positional_arguments]
REQUIRE(outputs[1] == "output.mesh");
}
TEST_CASE("Parse positional arguments with optional arguments", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse positional arguments with optional arguments [positional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("input");
program.add_argument("output").nargs(2);
@ -38,7 +38,7 @@ TEST_CASE("Parse positional arguments with optional arguments", "[positional_arg
REQUIRE(outputs[1] == "output.mesh");
}
TEST_CASE("Parse positional arguments with optional arguments in the middle", "[positional_arguments]") {
DOCTEST_TEST_CASE("Parse positional arguments with optional arguments in the middle [positional_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("input");
program.add_argument("output").nargs(2);
@ -47,8 +47,7 @@ TEST_CASE("Parse positional arguments with optional arguments in the middle", "[
REQUIRE_THROWS(program.parse_args({ "test", "rocket.mesh", "thrust_profile.csv", "--num_iterations", "15", "output.mesh" }));
}
TEST_CASE("Parse remaining arguments deemed positional",
"[positional_arguments]") {
DOCTEST_TEST_CASE("Parse remaining arguments deemed positional [positional_arguments]") {
GIVEN("a program that accepts an optional argument and remaining arguments") {
argparse::ArgumentParser program("test");
program.add_argument("-o");
@ -95,12 +94,12 @@ TEST_CASE("Parse remaining arguments deemed positional",
}
}
TEST_CASE("Negative nargs is not allowed", "[positional_arguments]") {
DOCTEST_TEST_CASE("Negative nargs is not allowed [positional_arguments]") {
argparse::ArgumentParser program("test");
REQUIRE_THROWS_AS(program.add_argument("output").nargs(-1), std::logic_error);
}
TEST_CASE("Square a number", "[positional_arguments]") {
DOCTEST_TEST_CASE("Square a number [positional_arguments]") {
argparse::ArgumentParser program;
program.add_argument("--verbose", "-v")
.help("enable verbose logging")

15
test/test_required_arguments.hpp → test/test_required_arguments.cpp
View File

@ -1,20 +1,19 @@
#pragma once
#include <catch.hpp>
#include <doctest.hpp>
#include <argparse.hpp>
TEST_CASE("Parse required arguments which are not set and don't have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are not set and don't have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required();
REQUIRE_THROWS(program.parse_args({ "./main" }));
}
TEST_CASE("Parse required arguments which are set as empty value and don't have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are set as empty value and don't have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required();
REQUIRE_THROWS(program.parse_args({ "./main", "-o" }));
}
TEST_CASE("Parse required arguments which are set as some value and don't have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are set as some value and don't have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required();
program.parse_args({ "./main", "-o", "filename" });
@ -22,7 +21,7 @@ TEST_CASE("Parse required arguments which are set as some value and don't have d
REQUIRE(program.get("-o") == "filename");
}
TEST_CASE("Parse required arguments which are not set and have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are not set and have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required().default_value(std::string("filename"));
program.parse_args({ "./main" });
@ -30,13 +29,13 @@ TEST_CASE("Parse required arguments which are not set and have default value.",
REQUIRE(program.get("-o") == "filename");
}
TEST_CASE("Parse required arguments which are set as empty and have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are set as empty and have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required().default_value(std::string("filename"));
REQUIRE_THROWS(program.parse_args({ "./main", "-o" }));
}
TEST_CASE("Parse required arguments which are set as some value and have default value.", "[required_arguments]") {
DOCTEST_TEST_CASE("Parse required arguments which are set as some value and have default value. [required_arguments]") {
argparse::ArgumentParser program("test");
program.add_argument("--output", "-o").required().default_value(std::string("filename"));
program.parse_args({ "./main", "-o", "anotherfile" });

9
test/test_value_semantics.hpp → test/test_value_semantics.cpp
View File

@ -1,9 +1,7 @@
#pragma once
#include <argparse.hpp>
#include <catch.hpp>
#include <doctest.hpp>
TEST_CASE("ArgumentParser is MoveConstructible and MoveAssignable",
"[value_semantics]") {
DOCTEST_TEST_CASE("ArgumentParser is MoveConstructible and MoveAssignable [value_semantics]") {
GIVEN("a parser that has two arguments") {
argparse::ArgumentParser parser("test");
parser.add_argument("foo");
@ -34,8 +32,7 @@ TEST_CASE("ArgumentParser is MoveConstructible and MoveAssignable",
}
}
TEST_CASE("ArgumentParser is CopyConstructible and CopyAssignable",
"[value_semantics]") {
DOCTEST_TEST_CASE("ArgumentParser is CopyConstructible and CopyAssignable [value_semantics]") {
GIVEN("a parser that has two arguments") {
argparse::ArgumentParser parser("test");
parser.add_argument("foo");