mirrors/CLI11
1
0
Fork 0
mirror of https://github.com/CLIUtils/CLI11.git synced 2025-04-30 12:43:52 +00:00
Code Issues Releases Wiki Activity
CLI11/tests/HelpersTest.cpp
Philip Top 91220babfc
regular and literal strings (#964) 
Add escaping to quoted strings, differentiate between literal and
regular strings.

The goal is to make string processing in config files as close as
possible to toml standards. This means handing escape sequences
including unicode, and differentiating between literal strings and
regular strings in files and when splitting the command line. Also
allowing variable names in the files to be quoted.

This PR gets partway there. Removes some hacks from the previous PR to
deal with unusual option names and replaces with the quoted names.

---------

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>
2023-12-30 06:54:41 -08:00

1621 lines
58 KiB
C++
Raw Blame History

// Copyright (c) 2017-2023, University of Cincinnati, developed by Henry Schreiner
// under NSF AWARD 1414736 and by the respective contributors.
// All rights reserved.
//
// SPDX-License-Identifier: BSD-3-Clause
#include "app_helper.hpp"
#include <cmath>
#include <array>
#include <atomic>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <fstream>
#include <limits>
#include <map>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
class NotStreamable {};
class Streamable {};
std::ostream &operator<<(std::ostream &out, const Streamable &) { return out << "Streamable"; }
TEST_CASE("TypeTools: Streaming", "[helpers]") {
CHECK(CLI::detail::to_string(NotStreamable{}).empty());
CHECK("Streamable" == CLI::detail::to_string(Streamable{}));
CHECK("5" == CLI::detail::to_string(5));
CHECK(std::string("string") == CLI::detail::to_string("string"));
CHECK(std::string("string") == CLI::detail::to_string(std::string("string")));
}
TEST_CASE("TypeTools: tuple", "[helpers]") {
CHECK_FALSE(CLI::detail::is_tuple_like<int>::value);
CHECK_FALSE(CLI::detail::is_tuple_like<std::vector<double>>::value);
auto v = CLI::detail::is_tuple_like<std::tuple<double, int>>::value;
CHECK(v);
v = CLI::detail::is_tuple_like<std::tuple<double, double, double>>::value;
CHECK(v);
}
TEST_CASE("TypeTools: type_size", "[helpers]") {
auto V = CLI::detail::type_count<int>::value;
CHECK(1 == V);
V = CLI::detail::type_count<void>::value;
CHECK(0 == V);
V = CLI::detail::type_count<std::vector<double>>::value;
CHECK(1 == V);
V = CLI::detail::type_count<std::tuple<double, int>>::value;
CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<std::string, double, int>>::value;
CHECK(3 == V);
V = CLI::detail::type_count<std::array<std::string, 5>>::value;
CHECK(5 == V);
V = CLI::detail::type_count<std::vector<std::pair<std::string, double>>>::value;
CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<std::pair<std::string, double>>>::value;
CHECK(2 == V);
V = CLI::detail::type_count<std::tuple<int, std::pair<std::string, double>>>::value;
CHECK(3 == V);
V = CLI::detail::type_count<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
CHECK(4 == V);
// maps
V = CLI::detail::type_count<std::map<int, std::pair<int, double>>>::value;
CHECK(3 == V);
// three level tuples
V = CLI::detail::type_count<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
CHECK(5 == V);
V = CLI::detail::type_count<std::pair<int, std::vector<int>>>::value;
CHECK(CLI::detail::expected_max_vector_size <= V);
V = CLI::detail::type_count<std::vector<std::vector<int>>>::value;
CHECK(CLI::detail::expected_max_vector_size == V);
}
TEST_CASE("TypeTools: type_size_min", "[helpers]") {
auto V = CLI::detail::type_count_min<int>::value;
CHECK(1 == V);
V = CLI::detail::type_count_min<void>::value;
CHECK(0 == V);
V = CLI::detail::type_count_min<std::vector<double>>::value;
CHECK(1 == V);
V = CLI::detail::type_count_min<std::tuple<double, int>>::value;
CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<std::string, double, int>>::value;
CHECK(3 == V);
V = CLI::detail::type_count_min<std::array<std::string, 5>>::value;
CHECK(5 == V);
V = CLI::detail::type_count_min<std::vector<std::pair<std::string, double>>>::value;
CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<std::pair<std::string, double>>>::value;
CHECK(2 == V);
V = CLI::detail::type_count_min<std::tuple<int, std::pair<std::string, double>>>::value;
CHECK(3 == V);
V = CLI::detail::type_count_min<std::tuple<std::pair<int, double>, std::pair<std::string, double>>>::value;
CHECK(4 == V);
// maps
V = CLI::detail::type_count_min<std::map<int, std::pair<int, double>>>::value;
CHECK(3 == V);
// three level tuples
V = CLI::detail::type_count_min<std::tuple<int, std::pair<int, std::tuple<int, double, std::string>>>>::value;
CHECK(5 == V);
V = CLI::detail::type_count_min<std::pair<int, std::vector<int>>>::value;
CHECK(2 == V);
V = CLI::detail::type_count_min<std::vector<std::vector<int>>>::value;
CHECK(1 == V);
V = CLI::detail::type_count_min<std::vector<std::vector<std::pair<int, int>>>>::value;
CHECK(2 == V);
}
TEST_CASE("TypeTools: expected_count", "[helpers]") {
auto V = CLI::detail::expected_count<int>::value;
CHECK(1 == V);
V = CLI::detail::expected_count<void>::value;
CHECK(0 == V);
V = CLI::detail::expected_count<std::vector<double>>::value;
CHECK(CLI::detail::expected_max_vector_size == V);
V = CLI::detail::expected_count<std::tuple<double, int>>::value;
CHECK(1 == V);
V = CLI::detail::expected_count<std::tuple<std::string, double, int>>::value;
CHECK(1 == V);
V = CLI::detail::expected_count<std::array<std::string, 5>>::value;
CHECK(1 == V);
V = CLI::detail::expected_count<std::vector<std::pair<std::string, double>>>::value;
CHECK(CLI::detail::expected_max_vector_size == V);
}
TEST_CASE("Split: SimpleByToken", "[helpers]") {
auto out = CLI::detail::split("one.two.three", '.');
REQUIRE(out.size() == 3u);
CHECK(out.at(0) == "one");
CHECK(out.at(1) == "two");
CHECK(out.at(2) == "three");
}
TEST_CASE("Split: Single", "[helpers]") {
auto out = CLI::detail::split("one", '.');
REQUIRE(out.size() == 1u);
CHECK(out.at(0) == "one");
}
TEST_CASE("Split: Empty", "[helpers]") {
auto out = CLI::detail::split("", '.');
REQUIRE(out.size() == 1u);
CHECK(out.at(0).empty());
}
TEST_CASE("String: InvalidName", "[helpers]") {
CHECK(CLI::detail::valid_name_string("valid"));
CHECK_FALSE(CLI::detail::valid_name_string("-invalid"));
CHECK(CLI::detail::valid_name_string("va-li-d"));
CHECK_FALSE(CLI::detail::valid_name_string("valid{}"));
CHECK(CLI::detail::valid_name_string("_valid"));
CHECK(CLI::detail::valid_name_string("/valid"));
CHECK(CLI::detail::valid_name_string("vali?d"));
CHECK(CLI::detail::valid_name_string("@@@@"));
CHECK(CLI::detail::valid_name_string("b@d2?"));
CHECK(CLI::detail::valid_name_string("2vali?d"));
CHECK_FALSE(CLI::detail::valid_name_string("!valid"));
CHECK_FALSE(CLI::detail::valid_name_string("!va\nlid"));
}
TEST_CASE("StringTools: Modify", "[helpers]") {
int cnt{0};
std::string newString = CLI::detail::find_and_modify("======", "=", [&cnt](std::string &str, std::size_t index) {
if((++cnt) % 2 == 0) {
str[index] = ':';
}
return index + 1;
});
CHECK("=:=:=:" == newString);
}
TEST_CASE("StringTools: Modify2", "[helpers]") {
std::string newString =
CLI::detail::find_and_modify("this is a string test", "is", [](std::string &str, std::size_t index) {
if((index > 1) && (str[index - 1] != ' ')) {
str[index] = 'a';
str[index + 1] = 't';
}
return index + 1;
});
CHECK("that is a string test" == newString);
}
TEST_CASE("StringTools: Modify3", "[helpers]") {
// this picks up 3 sets of 3 after the 'b' then collapses the new first set
std::string newString = CLI::detail::find_and_modify("baaaaaaaaaa", "aaa", [](std::string &str, std::size_t index) {
str.erase(index, 3);
str.insert(str.begin(), 'a');
return 0u;
});
CHECK("aba" == newString);
}
TEST_CASE("StringTools: flagValues", "[helpers]") {
errno = 0;
CHECK(-1 == CLI::detail::to_flag_value("0"));
CHECK(errno == 0);
CHECK(1 == CLI::detail::to_flag_value("t"));
CHECK(1 == CLI::detail::to_flag_value("1"));
CHECK(6 == CLI::detail::to_flag_value("6"));
CHECK(-6 == CLI::detail::to_flag_value("-6"));
CHECK(-1 == CLI::detail::to_flag_value("false"));
CHECK(1 == CLI::detail::to_flag_value("YES"));
errno = 0;
CLI::detail::to_flag_value("frog");
CHECK(errno == EINVAL);
errno = 0;
CLI::detail::to_flag_value("q");
CHECK(errno == EINVAL);
errno = 0;
CLI::detail::to_flag_value(
"77777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777");
CHECK(errno == ERANGE);
errno = 0;
CHECK(-1 == CLI::detail::to_flag_value("NO"));
CHECK(475555233 == CLI::detail::to_flag_value("475555233"));
}
TEST_CASE("StringTools: Validation", "[helpers]") {
CHECK(CLI::detail::isalpha(""));
CHECK(CLI::detail::isalpha("a"));
CHECK(CLI::detail::isalpha("abcd"));
CHECK_FALSE(CLI::detail::isalpha("_"));
CHECK_FALSE(CLI::detail::isalpha("2"));
CHECK_FALSE(CLI::detail::isalpha("test test"));
CHECK_FALSE(CLI::detail::isalpha("test "));
CHECK_FALSE(CLI::detail::isalpha(" test"));
CHECK_FALSE(CLI::detail::isalpha("test2"));
}
TEST_CASE("StringTools: binaryEscapseConversion", "[helpers]") {
std::string testString("string1");
std::string estring = CLI::detail::binary_escape_string(testString);
CHECK(testString == estring);
CHECK_FALSE(CLI::detail::is_binary_escaped_string(estring));
std::string testString2("\nstring1\n");
estring = CLI::detail::binary_escape_string(testString2);
CHECK_FALSE(testString == estring);
CHECK(CLI::detail::is_binary_escaped_string(estring));
std::string rstring = CLI::detail::extract_binary_string(estring);
CHECK(rstring == testString2);
CLI::detail::remove_quotes(estring);
CHECK(CLI::detail::is_binary_escaped_string(estring));
std::string rstringrq = CLI::detail::extract_binary_string(estring);
CHECK(rstringrq == testString2);
testString2.push_back(0);
testString2.push_back(static_cast<char>(197));
testString2.push_back(78);
testString2.push_back(-34);
rstring = CLI::detail::extract_binary_string(CLI::detail::binary_escape_string(testString2));
CHECK(rstring == testString2);
testString2.push_back('b');
testString2.push_back('G');
rstring = CLI::detail::extract_binary_string(CLI::detail::binary_escape_string(testString2));
CHECK(rstring == testString2);
auto rstring2 = CLI::detail::extract_binary_string(rstring);
CHECK(rstring == rstring2);
}
TEST_CASE("StringTools: binaryStrings", "[helpers]") {
std::string rstring = "B\"()\"";
CHECK(CLI::detail::extract_binary_string(rstring).empty());
rstring = "B\"(\\x35\\xa7)\"";
CHECK(CLI::detail::is_binary_escaped_string(rstring));
auto result = CLI::detail::extract_binary_string(rstring);
CHECK(result[0] == static_cast<char>(0x35));
CHECK(result[1] == static_cast<char>(0xa7));
rstring = "'B\"(\\x3e\\xf7)\"'";
CHECK(CLI::detail::is_binary_escaped_string(rstring));
result = CLI::detail::extract_binary_string(rstring);
CHECK(result[0] == static_cast<char>(0x3e));
CHECK(result[1] == static_cast<char>(0xf7));
rstring = "B\"(\\x3E\\xf7)\"";
result = CLI::detail::extract_binary_string(rstring);
CHECK(result[0] == static_cast<char>(0x3e));
CHECK(result[1] == static_cast<char>(0xf7));
rstring = "B\"(\\X3E\\XF7)\"";
result = CLI::detail::extract_binary_string(rstring);
CHECK(result[0] == static_cast<char>(0x3e));
CHECK(result[1] == static_cast<char>(0xf7));
rstring = "B\"(\\XME\\XK7)\"";
result = CLI::detail::extract_binary_string(rstring);
CHECK(result == "\\XME\\XK7");
rstring = "B\"(\\XEM\\X7K)\"";
result = CLI::detail::extract_binary_string(rstring);
CHECK(result == "\\XEM\\X7K");
}
/// these are provided for compatibility with the char8_t for C++20 that breaks stuff
std::string from_u8string(const std::string &s) { return s; }
std::string from_u8string(std::string &&s) { return std::move(s); }
#if defined(__cpp_lib_char8_t)
std::string from_u8string(const std::u8string &s) { return std::string(s.begin(), s.end()); }
#elif defined(__cpp_char8_t)
std::string from_u8string(const char8_t *s) { return std::string(reinterpret_cast<const char *>(s)); }
#endif
TEST_CASE("StringTools: escapeConversion", "[helpers]") {
CHECK(CLI::detail::remove_escaped_characters("test\\\"") == "test\"");
CHECK(CLI::detail::remove_escaped_characters("test\\\\") == "test\\");
CHECK(CLI::detail::remove_escaped_characters("test\\b") == "test\b");
CHECK(CLI::detail::remove_escaped_characters("test\\t") == "test\t");
CHECK(CLI::detail::remove_escaped_characters("test\\n\\r\\t\\f") == "test\n\r\t\f");
CHECK(CLI::detail::remove_escaped_characters("test\\r") == "test\r");
CHECK(CLI::detail::remove_escaped_characters("test\\f") == "test\f");
std::string zstring = "test";
zstring.push_back('\0');
zstring.append("test\n");
CHECK(CLI::detail::remove_escaped_characters("test\\0test\\n") == zstring);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\m_bad"), std::invalid_argument);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\"), std::invalid_argument);
}
TEST_CASE("StringTools: quotedString", "[helpers]") {
std::string rstring = "'B\"(\\x35\\xa7)\"'";
auto s2 = rstring;
CLI::detail::process_quoted_string(s2);
CHECK(s2[0] == static_cast<char>(0x35));
CHECK(s2[1] == static_cast<char>(0xa7));
s2 = rstring;
CLI::detail::remove_quotes(s2);
CLI::detail::process_quoted_string(s2);
CHECK(s2[0] == static_cast<char>(0x35));
CHECK(s2[1] == static_cast<char>(0xa7));
std::string qbase = R"("this\nis\na\nfour\tline test")";
std::string qresult = "this\nis\na\nfour\tline test";
std::string q1 = qbase;
// test remove quotes and escape processing
CLI::detail::process_quoted_string(q1);
CHECK(q1 == qresult);
std::string q2 = qbase;
q2.front() = '\'';
q2.pop_back();
q2.push_back('\'');
std::string qliteral = qbase.substr(1);
qliteral.pop_back();
// test remove quotes for literal string
CHECK(CLI::detail::process_quoted_string(q2));
CHECK(q2 == qliteral);
std::string q3 = qbase;
q3.front() = '`';
q3.pop_back();
q3.push_back('`');
// test remove quotes for literal string
CHECK(CLI::detail::process_quoted_string(q3));
CHECK(q3 == qliteral);
std::string q4 = qbase;
q4.front() = '|';
q4.pop_back();
q4.push_back('|');
// check that it doesn't process
CHECK_FALSE(CLI::detail::process_quoted_string(q4));
// test custom string quote character
CHECK(CLI::detail::process_quoted_string(q4, '|'));
CHECK(q4 == qresult);
std::string q5 = qbase;
q5.front() = '?';
q5.pop_back();
q5.push_back('?');
// test custom literal quote character
CHECK(CLI::detail::process_quoted_string(q5, '|', '?'));
CHECK(q5 == qliteral);
q3 = qbase;
q3.front() = '`';
q3.pop_back();
q3.push_back('`');
// test that '`' still works regardless of the other specified characters
CHECK(CLI::detail::process_quoted_string(q3));
CHECK(q3 == qliteral);
}
TEST_CASE("StringTools: unicode_literals", "[helpers]") {
CHECK(CLI::detail::remove_escaped_characters("test\\u03C0\\u00e9") == from_u8string(u8"test\u03C0\u00E9"));
CHECK(CLI::detail::remove_escaped_characters("test\\u73C0\\u0057") == from_u8string(u8"test\u73C0\u0057"));
CHECK(CLI::detail::remove_escaped_characters("test\\U0001F600\\u00E9") == from_u8string(u8"test\U0001F600\u00E9"));
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\U0001M600\\u00E9"), std::invalid_argument);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\U0001E600\\u00M9"), std::invalid_argument);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\U0001E600\\uD8E9"), std::invalid_argument);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\U0001E600\\uD8"), std::invalid_argument);
CHECK_THROWS_AS(CLI::detail::remove_escaped_characters("test\\U0001E60"), std::invalid_argument);
}
TEST_CASE("StringTools: close_sequence", "[helpers]") {
CHECK(CLI::detail::close_sequence("[test]", 0, ']') == 5U);
CHECK(CLI::detail::close_sequence("[\"test]\"]", 0, ']') == 8U);
CHECK(CLI::detail::close_sequence("[\"test]\"],[t2]", 0, ']') == 8U);
CHECK(CLI::detail::close_sequence("[\"test]\"],[t2]", 10, ']') == 13U);
CHECK(CLI::detail::close_sequence("{\"test]\"],[t2]", 0, '}') == 14U);
CHECK(CLI::detail::close_sequence("[(),(),{},\"]]52{}\",[],[54],[[],[],()]]", 0, ']') == 37U);
}
TEST_CASE("Trim: Various", "[helpers]") {
std::string s1{" sdlfkj sdflk sd s "};
std::string a1{"sdlfkj sdflk sd s"};
CLI::detail::trim(s1);
CHECK(s1 == a1);
std::string s2{" a \t"};
CLI::detail::trim(s2);
CHECK(s2 == "a");
std::string s3{" a \n"};
CLI::detail::trim(s3);
CHECK(s3 == "a");
std::string s4{" a b "};
CHECK(CLI::detail::trim(s4) == "a b");
}
TEST_CASE("Trim: VariousFilters", "[helpers]") {
std::string s1{" sdlfkj sdflk sd s "};
std::string a1{"sdlfkj sdflk sd s"};
CLI::detail::trim(s1, " ");
CHECK(s1 == a1);
std::string s2{" a \t"};
CLI::detail::trim(s2, " ");
CHECK(s2 == "a \t");
std::string s3{"abdavda"};
CLI::detail::trim(s3, "a");
CHECK(s3 == "bdavd");
std::string s4{"abcabcabc"};
CHECK(CLI::detail::trim(s4, "ab") == "cabcabc");
}
TEST_CASE("Trim: TrimCopy", "[helpers]") {
std::string orig{" cabc "};
std::string trimmed = CLI::detail::trim_copy(orig);
CHECK(trimmed == "cabc");
CHECK(trimmed != orig);
CLI::detail::trim(orig);
CHECK(orig == trimmed);
orig = "abcabcabc";
trimmed = CLI::detail::trim_copy(orig, "ab");
CHECK(trimmed == "cabcabc");
CHECK(trimmed != orig);
CLI::detail::trim(orig, "ab");
CHECK(orig == trimmed);
}
TEST_CASE("Validators: FileExists", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
CHECK(CLI::ExistingFile(myfile).empty());
std::remove(myfile.c_str());
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
TEST_CASE("Validators: FileNotExists", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
CHECK(CLI::NonexistentPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
CHECK_FALSE(CLI::NonexistentPath(myfile).empty());
std::remove(myfile.c_str());
CHECK(CLI::NonexistentPath(myfile).empty());
}
TEST_CASE("Validators: FilePathModifier", "[helpers]") {
std::string myfile{"../TestFileNotUsed_1.txt"};
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
std::string filename = "TestFileNotUsed_1.txt";
CLI::FileOnDefaultPath defPath("../");
CHECK(defPath(filename).empty());
CHECK(filename == myfile);
std::string filename2 = "nonexistingfile.csv";
CHECK_FALSE(defPath(filename2).empty());
// check it didn't modify the string
CHECK(filename2 == "nonexistingfile.csv");
CHECK(defPath(filename).empty());
std::remove(myfile.c_str());
CHECK_FALSE(defPath(myfile).empty());
// now test the no error version
CLI::FileOnDefaultPath defPathNoFail("../", false);
CHECK(defPathNoFail(filename2).empty());
CHECK(filename2 == "nonexistingfile.csv");
}
TEST_CASE("Validators: FileIsDir", "[helpers]") {
std::string mydir{"../tests"};
CHECK(!CLI::ExistingFile(mydir).empty());
}
TEST_CASE("Validators: DirectoryExists", "[helpers]") {
std::string mydir{"../tests"};
CHECK(CLI::ExistingDirectory(mydir).empty());
}
TEST_CASE("Validators: DirectoryNotExists", "[helpers]") {
std::string mydir{"nondirectory"};
CHECK(!CLI::ExistingDirectory(mydir).empty());
}
TEST_CASE("Validators: DirectoryIsFile", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
CHECK(CLI::NonexistentPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
CHECK_FALSE(CLI::ExistingDirectory(myfile).empty());
std::remove(myfile.c_str());
CHECK(CLI::NonexistentPath(myfile).empty());
}
TEST_CASE("Validators: PathExistsDir", "[helpers]") {
std::string mydir{"../tests"};
CHECK(CLI::ExistingPath(mydir).empty());
}
TEST_CASE("Validators: PathExistsFile", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
CHECK_FALSE(CLI::ExistingPath(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
CHECK(CLI::ExistingPath(myfile).empty());
std::remove(myfile.c_str());
CHECK_FALSE(CLI::ExistingPath(myfile).empty());
}
TEST_CASE("Validators: PathNotExistsDir", "[helpers]") {
std::string mydir{"nonpath"};
CHECK(!CLI::ExistingPath(mydir).empty());
}
TEST_CASE("Validators: IPValidate1", "[helpers]") {
std::string ip = "1.1.1.1";
CHECK(CLI::ValidIPV4(ip).empty());
ip = "224.255.0.1";
CHECK(CLI::ValidIPV4(ip).empty());
ip = "-1.255.0.1";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.256.0.1";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.256.0.1";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "aaa";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "1.2.3.abc";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
ip = "11.22";
CHECK_FALSE(CLI::ValidIPV4(ip).empty());
}
TEST_CASE("Validators: PositiveValidator", "[helpers]") {
std::string num = "1.1.1.1";
CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "1";
CHECK(CLI::PositiveNumber(num).empty());
num = "10000";
CHECK(CLI::PositiveNumber(num).empty());
num = "0";
CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "+0.5";
CHECK(CLI::PositiveNumber(num).empty());
num = "-1";
CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "-1.5";
CHECK_FALSE(CLI::PositiveNumber(num).empty());
num = "a";
CHECK_FALSE(CLI::PositiveNumber(num).empty());
}
TEST_CASE("Validators: NonNegativeValidator", "[helpers]") {
std::string num = "1.1.1.1";
CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "1";
CHECK(CLI::NonNegativeNumber(num).empty());
num = "10000";
CHECK(CLI::NonNegativeNumber(num).empty());
num = "0";
CHECK(CLI::NonNegativeNumber(num).empty());
num = "+0.5";
CHECK(CLI::NonNegativeNumber(num).empty());
num = "-1";
CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "-1.5";
CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
num = "a";
CHECK_FALSE(CLI::NonNegativeNumber(num).empty());
}
TEST_CASE("Validators: NumberValidator", "[helpers]") {
std::string num = "1.1.1.1";
CHECK_FALSE(CLI::Number(num).empty());
num = "1.7";
CHECK(CLI::Number(num).empty());
num = "10000";
CHECK(CLI::Number(num).empty());
num = "-0.000";
CHECK(CLI::Number(num).empty());
num = "+1.55";
CHECK(CLI::Number(num).empty());
num = "a";
CHECK_FALSE(CLI::Number(num).empty());
}
TEST_CASE("Validators: CombinedAndRange", "[helpers]") {
auto crange = CLI::Range(0, 12) & CLI::Range(4, 16);
CHECK(crange("4").empty());
CHECK(crange("12").empty());
CHECK(crange("7").empty());
CHECK_FALSE(crange("-2").empty());
CHECK_FALSE(crange("2").empty());
CHECK_FALSE(crange("15").empty());
CHECK_FALSE(crange("16").empty());
CHECK_FALSE(crange("18").empty());
}
TEST_CASE("Validators: CombinedOrRange", "[helpers]") {
auto crange = CLI::Range(0, 4) | CLI::Range(8, 12);
CHECK_FALSE(crange("-2").empty());
CHECK(crange("2").empty());
CHECK_FALSE(crange("5").empty());
CHECK(crange("8").empty());
CHECK(crange("12").empty());
CHECK_FALSE(crange("16").empty());
}
TEST_CASE("Validators: CombinedPaths", "[helpers]") {
std::string myfile{"TestFileNotUsed.txt"};
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
std::string dir{"../tests"};
std::string notpath{"nondirectory"};
auto path_or_dir = CLI::ExistingPath | CLI::ExistingDirectory;
CHECK(path_or_dir(dir).empty());
CHECK(path_or_dir(myfile).empty());
CHECK_FALSE(path_or_dir(notpath).empty());
auto file_or_dir = CLI::ExistingFile | CLI::ExistingDirectory;
CHECK(file_or_dir(dir).empty());
CHECK(file_or_dir(myfile).empty());
CHECK_FALSE(file_or_dir(notpath).empty());
auto path_and_dir = CLI::ExistingPath & CLI::ExistingDirectory;
CHECK(path_and_dir(dir).empty());
CHECK_FALSE(path_and_dir(myfile).empty());
CHECK_FALSE(path_and_dir(notpath).empty());
auto path_and_file = CLI::ExistingFile & CLI::ExistingDirectory;
CHECK_FALSE(path_and_file(dir).empty());
CHECK_FALSE(path_and_file(myfile).empty());
CHECK_FALSE(path_and_file(notpath).empty());
std::remove(myfile.c_str());
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
TEST_CASE("Validators: ProgramNameSplit", "[helpers]") {
TempFile myfile{"program_name1.exe"};
{
std::ofstream out{myfile};
out << "useless string doesn't matter" << std::endl;
}
auto res =
CLI::detail::split_program_name(std::string("./") + std::string(myfile) + " this is a bunch of extra stuff ");
CHECK(std::string("./") + std::string(myfile) == res.first);
CHECK("this is a bunch of extra stuff" == res.second);
TempFile myfile2{"program name1.exe"};
{
std::ofstream out{myfile2};
out << "useless string doesn't matter" << std::endl;
}
res = CLI::detail::split_program_name(std::string(" ") + std::string("./") + std::string(myfile2) +
" this is a bunch of extra stuff ");
CHECK(std::string("./") + std::string(myfile2) == res.first);
CHECK("this is a bunch of extra stuff" == res.second);
res = CLI::detail::split_program_name("./program_name this is a bunch of extra stuff ");
CHECK("./program_name" == res.first);
CHECK("this is a bunch of extra stuff" == res.second);
res = CLI::detail::split_program_name(std::string(" ./") + std::string(myfile) + " ");
CHECK(std::string("./") + std::string(myfile) == res.first);
CHECK(res.second.empty());
res = CLI::detail::split_program_name("'odd_program_name.exe --arg --arg2=5");
CHECK("'odd_program_name.exe" == res.first);
CHECK_FALSE(res.second.empty());
}
TEST_CASE("CheckedMultiply: Int", "[helpers]") {
int a{10};
int b{-20};
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(-200 == a);
a = 0;
b = -20;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0 == a);
a = 20;
b = 0;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0 == a);
a = (std::numeric_limits<int>::max)();
b = 1;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::max)() == a);
a = (std::numeric_limits<int>::max)();
b = 2;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::max)() == a);
a = (std::numeric_limits<int>::max)();
b = -1;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(-(std::numeric_limits<int>::max)() == a);
a = (std::numeric_limits<int>::max)();
b = (std::numeric_limits<int>::max)();
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::max)() == a);
a = (std::numeric_limits<int>::min)();
b = (std::numeric_limits<int>::max)();
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::min)() == a);
a = (std::numeric_limits<int>::min)();
b = 1;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::min)() == a);
a = (std::numeric_limits<int>::min)();
b = -1;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::min)() == a);
b = (std::numeric_limits<int>::min)();
a = -1;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE(-1 == a);
a = (std::numeric_limits<int>::min)() / 100;
b = 99;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::min)() / 100 * 99 == a);
a = (std::numeric_limits<int>::min)() / 100;
b = -101;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<int>::min)() / 100 == a);
a = 2;
b = (std::numeric_limits<int>::min)() / 2;
REQUIRE(CLI::detail::checked_multiply(a, b));
a = (std::numeric_limits<int>::min)() / 2;
b = 2;
REQUIRE(CLI::detail::checked_multiply(a, b));
a = 4;
b = (std::numeric_limits<int>::min)() / 4;
REQUIRE(CLI::detail::checked_multiply(a, b));
a = 48;
b = (std::numeric_limits<int>::min)() / 48;
REQUIRE(CLI::detail::checked_multiply(a, b));
}
TEST_CASE("CheckedMultiply: SizeT", "[helpers]") {
std::size_t a = 10;
std::size_t b = 20;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(200u == a);
a = 0u;
b = 20u;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0u == a);
a = 20u;
b = 0u;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0u == a);
a = (std::numeric_limits<std::size_t>::max)();
b = 1u;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<std::size_t>::max)() == a);
a = (std::numeric_limits<std::size_t>::max)();
b = 2u;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<std::size_t>::max)() == a);
a = (std::numeric_limits<std::size_t>::max)();
b = (std::numeric_limits<std::size_t>::max)();
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<std::size_t>::max)() == a);
a = (std::numeric_limits<std::size_t>::max)() / 100;
b = 99u;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<std::size_t>::max)() / 100u * 99u == a);
}
TEST_CASE("CheckedMultiply: Float", "[helpers]") {
float a{10.0F};
float b{20.0F};
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(200 == Approx(a));
a = 0.0F;
b = 20.0F;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0 == Approx(a));
a = INFINITY;
b = 20.0F;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(INFINITY == Approx(a));
a = 2.0F;
b = -INFINITY;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(-INFINITY == Approx(a));
a = (std::numeric_limits<float>::max)() / 100.0F;
b = 1.0F;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<float>::max)() / 100.0F == Approx(a));
a = (std::numeric_limits<float>::max)() / 100.0F;
b = 99.0F;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<float>::max)() / 100.0F * 99.0F == Approx(a));
a = (std::numeric_limits<float>::max)() / 100.0F;
b = 101;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<float>::max)() / 100.0F == Approx(a));
a = (std::numeric_limits<float>::max)() / 100.0F;
b = -99;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<float>::max)() / 100.0F * -99.0F == Approx(a));
a = (std::numeric_limits<float>::max)() / 100.0F;
b = -101;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<float>::max)() / 100.0F == Approx(a));
}
TEST_CASE("CheckedMultiply: Double", "[helpers]") {
double a{10.0F};
double b{20.0F};
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(200 == Approx(a));
a = 0;
b = 20;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(0 == Approx(a));
a = std::numeric_limits<double>::infinity();
b = 20;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(std::numeric_limits<double>::infinity() == Approx(a));
a = 2;
b = -std::numeric_limits<double>::infinity();
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE(-std::numeric_limits<double>::infinity() == Approx(a));
a = (std::numeric_limits<double>::max)() / 100;
b = 1;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<double>::max)() / 100 == Approx(a));
a = (std::numeric_limits<double>::max)() / 100;
b = 99;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<double>::max)() / 100 * 99 == Approx(a));
a = (std::numeric_limits<double>::max)() / 100;
b = 101;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<double>::max)() / 100 == Approx(a));
a = (std::numeric_limits<double>::max)() / 100;
b = -99;
REQUIRE(CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<double>::max)() / 100 * -99 == Approx(a));
a = (std::numeric_limits<double>::max)() / 100;
b = -101;
REQUIRE(!CLI::detail::checked_multiply(a, b));
REQUIRE((std::numeric_limits<double>::max)() / 100 == Approx(a));
}
// Yes, this is testing an app_helper :)
TEST_CASE("AppHelper: TempfileCreated", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
TempFile myfile{name};
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
bool ok = static_cast<bool>(std::ofstream(myfile.c_str()).put('a')); // create file
CHECK(ok);
CHECK(CLI::ExistingFile(name).empty());
CHECK_THROWS_AS([&]() { TempFile otherfile(name); }(), std::runtime_error);
}
CHECK_FALSE(CLI::ExistingFile(name).empty());
}
TEST_CASE("AppHelper: TempfileNotCreated", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
TempFile myfile{name};
CHECK_FALSE(CLI::ExistingFile(myfile).empty());
}
CHECK_FALSE(CLI::ExistingFile(name).empty());
}
TEST_CASE("AppHelper: Ofstream", "[helpers]") {
std::string name = "TestFileNotUsed.txt";
{
TempFile myfile(name);
{
std::ofstream out{myfile};
out << "this is output" << std::endl;
}
CHECK(CLI::ExistingFile(myfile).empty());
}
CHECK_FALSE(CLI::ExistingFile(name).empty());
}
TEST_CASE("Split: StringList", "[helpers]") {
std::vector<std::string> results{"a", "long", "--lone", "-q"};
CHECK(CLI::detail::split_names("a,long,--lone,-q") == results);
CHECK(CLI::detail::split_names(" a, long, --lone, -q") == results);
CHECK(CLI::detail::split_names(" a , long , --lone , -q ") == results);
CHECK(CLI::detail::split_names(" a , long , --lone , -q ") == results);
CHECK(CLI::detail::split_names("one") == std::vector<std::string>({"one"}));
}
TEST_CASE("RegEx: Shorts", "[helpers]") {
std::string name, value;
CHECK(CLI::detail::split_short("-a", name, value));
CHECK(name == "a");
CHECK(value.empty());
CHECK(CLI::detail::split_short("-B", name, value));
CHECK(name == "B");
CHECK(value.empty());
CHECK(CLI::detail::split_short("-cc", name, value));
CHECK(name == "c");
CHECK(value == "c");
CHECK(CLI::detail::split_short("-simple", name, value));
CHECK(name == "s");
CHECK(value == "imple");
CHECK_FALSE(CLI::detail::split_short("--a", name, value));
CHECK_FALSE(CLI::detail::split_short("--thing", name, value));
CHECK_FALSE(CLI::detail::split_short("--", name, value));
CHECK_FALSE(CLI::detail::split_short("something", name, value));
CHECK_FALSE(CLI::detail::split_short("s", name, value));
}
TEST_CASE("RegEx: Longs", "[helpers]") {
std::string name, value;
CHECK(CLI::detail::split_long("--a", name, value));
CHECK(name == "a");
CHECK(value.empty());
CHECK(CLI::detail::split_long("--thing", name, value));
CHECK(name == "thing");
CHECK(value.empty());
CHECK(CLI::detail::split_long("--some=thing", name, value));
CHECK(name == "some");
CHECK(value == "thing");
CHECK_FALSE(CLI::detail::split_long("-a", name, value));
CHECK_FALSE(CLI::detail::split_long("-things", name, value));
CHECK_FALSE(CLI::detail::split_long("Q", name, value));
CHECK_FALSE(CLI::detail::split_long("--", name, value));
}
TEST_CASE("RegEx: SplittingNew", "[helpers]") {
std::vector<std::string> shorts;
std::vector<std::string> longs;
std::string pname;
CHECK_NOTHROW(std::tie(shorts, longs, pname) = CLI::detail::get_names({"--long", "-s", "-q", "--also-long"}));
CHECK(longs == std::vector<std::string>({"long", "also-long"}));
CHECK(shorts == std::vector<std::string>({"s", "q"}));
CHECK(pname.empty());
std::tie(shorts, longs, pname) = CLI::detail::get_names({"--long", "", "-s", "-q", "", "--also-long"});
CHECK(longs == std::vector<std::string>({"long", "also-long"}));
CHECK(shorts == std::vector<std::string>({"s", "q"}));
CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"-"}); }(), CLI::BadNameString);
CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"--"}); }(), CLI::BadNameString);
CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"-hi"}); }(), CLI::BadNameString);
CHECK_THROWS_AS([&]() { std::tie(shorts, longs, pname) = CLI::detail::get_names({"---hi"}); }(),
CLI::BadNameString);
CHECK_THROWS_AS(
[&]() {
std::tie(shorts, longs, pname) = CLI::detail::get_names({"one", "two"});
}(),
CLI::BadNameString);
}
TEST_CASE("String: ToLower", "[helpers]") { CHECK("one and two" == CLI::detail::to_lower("one And TWO")); }
TEST_CASE("Join: Forward", "[helpers]") {
std::vector<std::string> val{{"one", "two", "three"}};
CHECK(CLI::detail::join(val) == "one,two,three");
CHECK(CLI::detail::join(val, ";") == "one;two;three");
}
TEST_CASE("Join: Backward", "[helpers]") {
std::vector<std::string> val{{"three", "two", "one"}};
CHECK(CLI::detail::rjoin(val) == "one,two,three");
CHECK(CLI::detail::rjoin(val, ";") == "one;two;three");
}
TEST_CASE("SplitUp: Simple", "[helpers]") {
std::vector<std::string> oput = {"one", "\"two three\""};
std::string orig{R"(one "two three")"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: SimpleDifferentQuotes", "[helpers]") {
std::vector<std::string> oput = {"one", "`two three`"};
std::string orig{R"(one `two three`)"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: SimpleMissingQuotes", "[helpers]") {
std::vector<std::string> oput = {"one", "`two three"};
std::string orig{R"(one `two three)"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: SimpleMissingQuotesEscaped", "[helpers]") {
std::vector<std::string> oput = {"one", R"("two three\"")"};
std::string orig{R"(one "two three\"")"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: SimpleDifferentQuotes2", "[helpers]") {
std::vector<std::string> oput = {"one", "'two three'"};
std::string orig{R"(one 'two three')"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: Bracket1", "[helpers]") {
std::vector<std::string> oput = {"one", "[two, three]"};
std::string orig{"one, [two, three]"};
std::vector<std::string> result = CLI::detail::split_up(orig, ',');
CHECK(result == oput);
}
TEST_CASE("SplitUp: Bracket2", "[helpers]") {
std::vector<std::string> oput = {"one", "<two, three>"};
std::string orig{"one, <two, three>"};
std::vector<std::string> result = CLI::detail::split_up(orig, ',');
CHECK(result == oput);
}
TEST_CASE("SplitUp: Bracket3", "[helpers]") {
std::vector<std::string> oput = {"one", "(two, three)"};
std::string orig{"one, (two, three)"};
std::vector<std::string> result = CLI::detail::split_up(orig, ',');
CHECK(result == oput);
}
TEST_CASE("SplitUp: Bracket4", "[helpers]") {
std::vector<std::string> oput = {"one", "{two, three}"};
std::string orig{"one, {two, three}"};
std::vector<std::string> result = CLI::detail::split_up(orig, ',');
CHECK(result == oput);
}
TEST_CASE("SplitUp: Comment", "[helpers]") {
std::vector<std::string> oput = {R"(["quote1", "#"])"};
std::string orig{R"(["quote1", "#"])"};
std::vector<std::string> result = CLI::detail::split_up(orig, '#');
CHECK(result == oput);
}
TEST_CASE("SplitUp: Layered", "[helpers]") {
std::vector<std::string> output = {R"("one 'two three'")"};
std::string orig{R"("one 'two three'")"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == output);
}
TEST_CASE("SplitUp: Spaces", "[helpers]") {
std::vector<std::string> oput = {"one", "\" two three\""};
std::string orig{R"( one " two three" )"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("SplitUp: BadStrings", "[helpers]") {
std::vector<std::string> oput = {"one", "\" two three"};
std::string orig{R"( one " two three )"};
std::vector<std::string> result = CLI::detail::split_up(orig);
CHECK(result == oput);
oput = {"one", "' two three"};
orig = R"( one ' two three )";
result = CLI::detail::split_up(orig);
CHECK(result == oput);
}
TEST_CASE("Types: TypeName", "[helpers]") {
std::string int_name = CLI::detail::type_name<int>();
CHECK(int_name == "INT");
std::string int2_name = CLI::detail::type_name<std::int16_t>();
CHECK(int2_name == "INT");
std::string uint_name = CLI::detail::type_name<unsigned char>();
CHECK(uint_name == "UINT");
std::string float_name = CLI::detail::type_name<double>();
CHECK(float_name == "FLOAT");
std::string char_name = CLI::detail::type_name<char>();
CHECK(char_name == "CHAR");
std::string vector_name = CLI::detail::type_name<std::vector<int>>();
CHECK(vector_name == "INT");
vector_name = CLI::detail::type_name<std::vector<double>>();
CHECK(vector_name == "FLOAT");
static_assert(CLI::detail::classify_object<std::pair<int, std::string>>::value ==
CLI::detail::object_category::tuple_value,
"pair<int,string> does not read like a tuple");
static_assert(CLI::detail::classify_object<std::tuple<std::string, double>>::value ==
CLI::detail::object_category::tuple_value,
"tuple<string,double> does not read like a tuple");
std::string pair_name = CLI::detail::type_name<std::vector<std::pair<int, std::string>>>();
CHECK(pair_name == "[INT,TEXT]");
vector_name = CLI::detail::type_name<std::vector<std::vector<unsigned char>>>();
CHECK(vector_name == "UINT");
auto vclass = CLI::detail::classify_object<std::vector<std::vector<unsigned char>>>::value;
CHECK(CLI::detail::object_category::container_value == vclass);
auto tclass = CLI::detail::classify_object<std::tuple<double>>::value;
CHECK(CLI::detail::object_category::number_constructible == tclass);
std::string tuple_name = CLI::detail::type_name<std::tuple<double>>();
CHECK(tuple_name == "FLOAT");
static_assert(CLI::detail::classify_object<std::tuple<int, std::string>>::value ==
CLI::detail::object_category::tuple_value,
"tuple<int,string> does not read like a tuple");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string>>();
CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<std::tuple<const int, std::string>>();
CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<const std::tuple<int, std::string>>();
CHECK(tuple_name == "[INT,TEXT]");
tuple_name = CLI::detail::type_name<std::tuple<std::string, double>>();
CHECK(tuple_name == "[TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<const std::tuple<std::string, double>>();
CHECK(tuple_name == "[TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double>>();
CHECK(tuple_name == "[INT,TEXT,FLOAT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double, unsigned int>>();
CHECK(tuple_name == "[INT,TEXT,FLOAT,UINT]");
tuple_name = CLI::detail::type_name<std::tuple<int, std::string, double, unsigned int, std::string>>();
CHECK(tuple_name == "[INT,TEXT,FLOAT,UINT,TEXT]");
tuple_name = CLI::detail::type_name<std::array<int, 10>>();
CHECK(tuple_name == "[INT,INT,INT,INT,INT,INT,INT,INT,INT,INT]");
std::string text_name = CLI::detail::type_name<std::string>();
CHECK(text_name == "TEXT");
std::string text2_name = CLI::detail::type_name<char *>();
CHECK(text2_name == "TEXT");
enum class test { test1, test2, test3 };
std::string enum_name = CLI::detail::type_name<test>();
CHECK(enum_name == "ENUM");
vclass = CLI::detail::classify_object<std::tuple<test>>::value;
CHECK(CLI::detail::object_category::tuple_value == vclass);
static_assert(CLI::detail::classify_object<std::tuple<test>>::value == CLI::detail::object_category::tuple_value,
"tuple<test> does not classify as a tuple");
std::string enum_name2 = CLI::detail::type_name<std::tuple<test>>();
CHECK(enum_name2 == "ENUM");
std::string umapName = CLI::detail::type_name<std::unordered_map<int, std::tuple<std::string, double>>>();
CHECK(umapName == "[INT,[TEXT,FLOAT]]");
// On older compilers, this may show up as other/TEXT
vclass = CLI::detail::classify_object<std::atomic<int>>::value;
CHECK((CLI::detail::object_category::wrapper_value == vclass || CLI::detail::object_category::other == vclass));
std::string atomic_name = CLI::detail::type_name<std::atomic<int>>();
CHECK((atomic_name == "INT" || atomic_name == "TEXT"));
}
TEST_CASE("Types: TypeNameStrings", "[helpers]") {
auto sclass = CLI::detail::classify_object<std::string>::value;
CHECK(CLI::detail::object_category::string_assignable == sclass);
auto wsclass = CLI::detail::classify_object<std::wstring>::value;
CHECK(CLI::detail::object_category::wstring_assignable == wsclass);
#if defined CLI11_HAS_FILEYSTEM && CLI11_HAS_FILESYSTEM > 0 && defined(_MSC_VER)
auto fspclass = CLI::detail::classify_object<std::filesystem::path>::value;
CHECK(CLI::detail::object_category::wstring_assignable == fspclass);
#endif
}
TEST_CASE("Types: OverflowSmall", "[helpers]") {
signed char x = 0;
auto strmax = std::to_string((std::numeric_limits<signed char>::max)() + 1);
CHECK_FALSE(CLI::detail::lexical_cast(strmax, x));
unsigned char y = 0;
strmax = std::to_string((std::numeric_limits<unsigned char>::max)() + 1);
CHECK_FALSE(CLI::detail::lexical_cast(strmax, y));
}
TEST_CASE("Types: LexicalCastInt", "[helpers]") {
std::string signed_input = "-912";
int x_signed = 0;
CHECK(CLI::detail::lexical_cast(signed_input, x_signed));
CHECK(x_signed == -912);
std::string unsigned_input = "912";
unsigned int x_unsigned = 0;
CHECK(CLI::detail::lexical_cast(unsigned_input, x_unsigned));
CHECK(x_unsigned == (unsigned int)912);
CHECK_FALSE(CLI::detail::lexical_cast(signed_input, x_unsigned));
unsigned char y = 0;
std::string overflow_input = std::to_string((std::numeric_limits<uint64_t>::max)()) + "0";
CHECK_FALSE(CLI::detail::lexical_cast(overflow_input, y));
char y_signed = 0;
CHECK_FALSE(CLI::detail::lexical_cast(overflow_input, y_signed));
std::string bad_input = "hello";
CHECK_FALSE(CLI::detail::lexical_cast(bad_input, y));
std::string extra_input = "912i";
CHECK_FALSE(CLI::detail::lexical_cast(extra_input, y));
extra_input = "true";
CHECK(CLI::detail::lexical_cast(extra_input, x_signed));
CHECK(x_signed != 0);
std::string empty_input{};
CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x_signed));
CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x_unsigned));
CHECK_FALSE(CLI::detail::lexical_cast(empty_input, y_signed));
}
TEST_CASE("Types: LexicalCastDouble", "[helpers]") {
std::string input = "9.12";
long double x = NAN;
CHECK(CLI::detail::lexical_cast(input, x));
CHECK((float)x == Approx((float)9.12));
std::string bad_input = "hello";
CHECK_FALSE(CLI::detail::lexical_cast(bad_input, x));
std::string overflow_input = "1" + std::to_string((std::numeric_limits<long double>::max)());
CHECK(CLI::detail::lexical_cast(overflow_input, x));
CHECK_FALSE(std::isfinite(x));
std::string extra_input = "9.12i";
CHECK_FALSE(CLI::detail::lexical_cast(extra_input, x));
std::string empty_input{};
CHECK_FALSE(CLI::detail::lexical_cast(empty_input, x));
}
TEST_CASE("Types: LexicalCastBool", "[helpers]") {
std::string input = "false";
bool x = false;
CHECK(CLI::detail::lexical_cast(input, x));
CHECK_FALSE(x);
std::string bad_input = "happy";
CHECK_FALSE(CLI::detail::lexical_cast(bad_input, x));
std::string input_true = "EnaBLE";
CHECK(CLI::detail::lexical_cast(input_true, x));
CHECK(x);
}
TEST_CASE("Types: LexicalCastString", "[helpers]") {
std::string input = "one";
std::string output;
CLI::detail::lexical_cast(input, output);
CHECK(output == input);
}
TEST_CASE("Types: LexicalCastParsable", "[helpers]") {
std::string input = "(4.2,7.3)";
std::string fail_input = "4.2,7.3";
std::string extra_input = "(4.2,7.3)e";
std::complex<double> output;
CHECK(CLI::detail::lexical_cast(input, output));
CHECK(4.2 == Approx(output.real()));
CHECK(7.3 == Approx(output.imag()));
CHECK(CLI::detail::lexical_cast("2.456", output));
CHECK(2.456 == Approx(output.real()));
CHECK(0.0 == Approx(output.imag()));
CHECK_FALSE(CLI::detail::lexical_cast(fail_input, output));
CHECK_FALSE(CLI::detail::lexical_cast(extra_input, output));
}
TEST_CASE("Types: LexicalCastEnum", "[helpers]") {
enum t1 : signed char { v1 = 5, v3 = 7, v5 = -9 };
t1 output = v1;
CHECK(CLI::detail::lexical_cast("-9", output));
CHECK(v5 == output);
CHECK_FALSE(CLI::detail::lexical_cast("invalid", output));
enum class t2 : std::uint64_t { enum1 = 65, enum2 = 45667, enum3 = 9999999999999 };
t2 output2{t2::enum2};
CHECK(CLI::detail::lexical_cast("65", output2));
CHECK(t2::enum1 == output2);
CHECK_FALSE(CLI::detail::lexical_cast("invalid", output2));
CHECK(CLI::detail::lexical_cast("9999999999999", output2));
CHECK(t2::enum3 == output2);
}
TEST_CASE("Types: LexicalConversionDouble", "[helpers]") {
CLI::results_t input = {"9.12"};
long double x{0.0};
bool res = CLI::detail::lexical_conversion<long double, double>(input, x);
CHECK(res);
CHECK((float)x == Approx((float)9.12));
CLI::results_t bad_input = {"hello"};
res = CLI::detail::lexical_conversion<long double, double>(bad_input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionDoubleTuple", "[helpers]") {
CLI::results_t input = {"9.12"};
std::tuple<double> x{0.0};
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(std::get<0>(x) == Approx(9.12));
CLI::results_t bad_input = {"hello"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(bad_input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionVectorDouble", "[helpers]") {
CLI::results_t input = {"9.12", "10.79", "-3.54"};
std::vector<double> x;
bool res = CLI::detail::lexical_conversion<std::vector<double>, double>(input, x);
CHECK(res);
CHECK(3u == x.size());
CHECK(-3.54 == Approx(x[2]));
res = CLI::detail::lexical_conversion<std::vector<double>, std::vector<double>>(input, x);
CHECK(res);
CHECK(3u == x.size());
CHECK(-3.54 == Approx(x[2]));
}
static_assert(!CLI::detail::is_tuple_like<std::vector<double>>::value, "vector should not be like a tuple");
static_assert(CLI::detail::is_tuple_like<std::pair<double, double>>::value, "pair of double should be like a tuple");
static_assert(CLI::detail::is_tuple_like<std::array<double, 4>>::value, "std::array<double,4> should be like a tuple");
static_assert(CLI::detail::is_tuple_like<std::array<int, 10>>::value, "std::array<int,10> should be like a tuple");
static_assert(!CLI::detail::is_tuple_like<std::string>::value, "std::string should not be like a tuple");
static_assert(!CLI::detail::is_tuple_like<double>::value, "double should not be like a tuple");
static_assert(CLI::detail::is_tuple_like<std::tuple<double, int, double>>::value, "tuple should look like a tuple");
TEST_CASE("Types: LexicalConversionTuple2", "[helpers]") {
CLI::results_t input = {"9.12", "19"};
std::tuple<double, int> x{0.0, 0};
static_assert(CLI::detail::is_tuple_like<decltype(x)>::value,
"tuple type must have is_tuple_like trait to be true");
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(19 == std::get<1>(x));
CHECK(9.12 == Approx(std::get<0>(x)));
input = {"19", "9.12"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionTuple3", "[helpers]") {
CLI::results_t input = {"9.12", "19", "hippo"};
std::tuple<double, int, std::string> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(19 == std::get<1>(x));
CHECK(9.12 == Approx(std::get<0>(x)));
CHECK("hippo" == std::get<2>(x));
input = {"19", "9.12"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionTuple4", "[helpers]") {
CLI::results_t input = {"9.12", "19", "18.6", "5.87"};
std::array<double, 4> x;
auto tsize = CLI::detail::type_count<decltype(x)>::value;
CHECK(tsize == 4);
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(19 == Approx(std::get<1>(x)));
CHECK(9.12 == Approx(x[0]));
CHECK(18.6 == Approx(x[2]));
CHECK(5.87 == Approx(x[3]));
input = {"19", "9.12", "hippo"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionTuple5", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235"};
std::array<unsigned int, 5> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(19u == std::get<1>(x));
CHECK(9u == x[0]);
CHECK(18u == x[2]);
CHECK(5u == x[3]);
CHECK(235235u == x[4]);
input = {"19", "9.12", "hippo"};
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionTuple10", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
std::array<unsigned int, 10> x;
bool res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK(res);
CHECK(19u == std::get<1>(x));
CHECK(9u == x[0]);
CHECK(18u == x[2]);
CHECK(5u == x[3]);
CHECK(235235u == x[4]);
CHECK(235235u == x[9]);
input[3] = "hippo";
res = CLI::detail::lexical_conversion<decltype(x), decltype(x)>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionTuple10XC", "[helpers]") {
CLI::results_t input = {"9", "19", "18", "5", "235235", "9", "19", "18", "5", "235235"};
std::array<double, 10> x;
bool res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
CHECK(res);
CHECK(19.0 == std::get<1>(x));
CHECK(9.0 == x[0]);
CHECK(18.0 == x[2]);
CHECK(5.0 == x[3]);
CHECK(235235.0 == x[4]);
CHECK(235235.0 == x[9]);
input[3] = "19.7";
res = CLI::detail::lexical_conversion<decltype(x), std::array<unsigned int, 10>>(input, x);
CHECK_FALSE(res);
}
TEST_CASE("Types: LexicalConversionComplex", "[helpers]") {
CLI::results_t input = {"5.1", "3.5"};
std::complex<double> x;
bool res = CLI::detail::lexical_conversion<std::complex<double>, std::array<double, 2>>(input, x);
CHECK(res);
CHECK(5.1 == x.real());
CHECK(3.5 == x.imag());
}
static_assert(CLI::detail::is_wrapper<std::vector<double>>::value, "vector double should be a wrapper");
static_assert(CLI::detail::is_wrapper<std::vector<std::string>>::value, "vector string should be a wrapper");
static_assert(CLI::detail::is_wrapper<std::string>::value, "string should be a wrapper");
static_assert(!CLI::detail::is_wrapper<double>::value, "double should not be a wrapper");
static_assert(CLI::detail::is_mutable_container<std::vector<double>>::value, "vector class should be a container");
static_assert(CLI::detail::is_mutable_container<std::vector<std::string>>::value, "vector class should be a container");
static_assert(!CLI::detail::is_mutable_container<std::string>::value, "string should be a container");
static_assert(!CLI::detail::is_mutable_container<double>::value, "double should not be a container");
static_assert(!CLI::detail::is_mutable_container<std::array<double, 5>>::value, "array should not be a container");
static_assert(CLI::detail::is_mutable_container<std::vector<int>>::value, "vector int should be a container");
static_assert(CLI::detail::is_readable_container<std::vector<int> &>::value,
"vector int & should be a readable container");
static_assert(CLI::detail::is_readable_container<const std::vector<int>>::value,
"const vector int should be a readable container");
static_assert(CLI::detail::is_readable_container<const std::vector<int> &>::value,
"const vector int & should be a readable container");
TEST_CASE("FixNewLines: BasicCheck", "[helpers]") {
std::string input = "one\ntwo";
std::string output = "one\n; two";
std::string result = CLI::detail::fix_newlines("; ", input);
CHECK(output == result);
}
TEST_CASE("FixNewLines: EdgesCheck", "[helpers]") {
std::string input = "\none\ntwo\n";
std::string output = "\n; one\n; two\n; ";
std::string result = CLI::detail::fix_newlines("; ", input);
CHECK(output == result);
}
TEST_CASE("String: environment", "[helpers]") {
put_env("TEST1", "TESTS");
auto value = CLI::detail::get_environment_value("TEST1");
CHECK(value == "TESTS");
unset_env("TEST1");
value = CLI::detail::get_environment_value("TEST2");
CHECK(value.empty());
}
Reference in New Issue View Git Blame Copy Permalink