diff options
Diffstat (limited to 'third_party/abseil_cpp/absl/flags/parse_test.cc')
| -rw-r--r-- | third_party/abseil_cpp/absl/flags/parse_test.cc | 898 |
1 files changed, 0 insertions, 898 deletions
diff --git a/third_party/abseil_cpp/absl/flags/parse_test.cc b/third_party/abseil_cpp/absl/flags/parse_test.cc deleted file mode 100644 index d35a6e471a..0000000000 --- a/third_party/abseil_cpp/absl/flags/parse_test.cc +++ /dev/null @@ -1,898 +0,0 @@ -// -// Copyright 2019 The Abseil Authors. -// -// Licensed under the Apache License, Version 2.0 (the "License"); -// you may not use this file except in compliance with the License. -// You may obtain a copy of the License at -// -// https://www.apache.org/licenses/LICENSE-2.0 -// -// Unless required by applicable law or agreed to in writing, software -// distributed under the License is distributed on an "AS IS" BASIS, -// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -// See the License for the specific language governing permissions and -// limitations under the License. - -#include "absl/flags/parse.h" - -#include <stdlib.h> - -#include <fstream> -#include <string> -#include <vector> - -#include "gmock/gmock.h" -#include "gtest/gtest.h" -#include "absl/base/internal/raw_logging.h" -#include "absl/base/internal/scoped_set_env.h" -#include "absl/flags/declare.h" -#include "absl/flags/flag.h" -#include "absl/flags/internal/parse.h" -#include "absl/flags/reflection.h" -#include "absl/strings/str_cat.h" -#include "absl/strings/string_view.h" -#include "absl/strings/substitute.h" -#include "absl/types/span.h" - -#ifdef _WIN32 -#include <windows.h> -#endif - -namespace { - -using absl::base_internal::ScopedSetEnv; - -struct UDT { - UDT() = default; - UDT(const UDT&) = default; - UDT(int v) : value(v) {} // NOLINT - - int value; -}; - -bool AbslParseFlag(absl::string_view in, UDT* udt, std::string* err) { - if (in == "A") { - udt->value = 1; - return true; - } - if (in == "AAA") { - udt->value = 10; - return true; - } - - *err = "Use values A, AAA instead"; - return false; -} -std::string AbslUnparseFlag(const UDT& udt) { - return udt.value == 1 ? "A" : "AAA"; -} - -std::string GetTestTmpDirEnvVar(const char* const env_var_name) { -#ifdef _WIN32 - char buf[MAX_PATH]; - auto get_res = GetEnvironmentVariableA(env_var_name, buf, sizeof(buf)); - if (get_res >= sizeof(buf) || get_res == 0) { - return ""; - } - - return std::string(buf, get_res); -#else - const char* val = ::getenv(env_var_name); - if (val == nullptr) { - return ""; - } - - return val; -#endif -} - -const std::string& GetTestTempDir() { - static std::string* temp_dir_name = []() -> std::string* { - std::string* res = new std::string(GetTestTmpDirEnvVar("TEST_TMPDIR")); - - if (res->empty()) { - *res = GetTestTmpDirEnvVar("TMPDIR"); - } - - if (res->empty()) { -#ifdef _WIN32 - char temp_path_buffer[MAX_PATH]; - - auto len = GetTempPathA(MAX_PATH, temp_path_buffer); - if (len < MAX_PATH && len != 0) { - std::string temp_dir_name = temp_path_buffer; - if (!absl::EndsWith(temp_dir_name, "\\")) { - temp_dir_name.push_back('\\'); - } - absl::StrAppend(&temp_dir_name, "parse_test.", GetCurrentProcessId()); - if (CreateDirectoryA(temp_dir_name.c_str(), nullptr)) { - *res = temp_dir_name; - } - } -#else - char temp_dir_template[] = "/tmp/parse_test.XXXXXX"; - if (auto* unique_name = ::mkdtemp(temp_dir_template)) { - *res = unique_name; - } -#endif - } - - if (res->empty()) { - ABSL_INTERNAL_LOG(FATAL, - "Failed to make temporary directory for data files"); - } - -#ifdef _WIN32 - *res += "\\"; -#else - *res += "/"; -#endif - - return res; - }(); - - return *temp_dir_name; -} - -struct FlagfileData { - const absl::string_view file_name; - const absl::Span<const char* const> file_lines; -}; - -// clang-format off -constexpr const char* const ff1_data[] = { - "# comment ", - " # comment ", - "", - " ", - "--int_flag=-1", - " --string_flag=q2w2 ", - " ## ", - " --double_flag=0.1", - "--bool_flag=Y " -}; - -constexpr const char* const ff2_data[] = { - "# Setting legacy flag", - "--legacy_int=1111", - "--legacy_bool", - "--nobool_flag", - "--legacy_str=aqsw", - "--int_flag=100", - " ## =============" -}; -// clang-format on - -// Builds flagfile flag in the flagfile_flag buffer and returns it. This -// function also creates a temporary flagfile based on FlagfileData input. -// We create a flagfile in a temporary directory with the name specified in -// FlagfileData and populate it with lines specifed in FlagfileData. If $0 is -// referenced in any of the lines in FlagfileData they are replaced with -// temporary directory location. This way we can test inclusion of one flagfile -// from another flagfile. -const char* GetFlagfileFlag(const std::vector<FlagfileData>& ffd, - std::string& flagfile_flag) { - flagfile_flag = "--flagfile="; - absl::string_view separator; - for (const auto& flagfile_data : ffd) { - std::string flagfile_name = - absl::StrCat(GetTestTempDir(), flagfile_data.file_name); - - std::ofstream flagfile_out(flagfile_name); - for (auto line : flagfile_data.file_lines) { - flagfile_out << absl::Substitute(line, GetTestTempDir()) << "\n"; - } - - absl::StrAppend(&flagfile_flag, separator, flagfile_name); - separator = ","; - } - - return flagfile_flag.c_str(); -} - -} // namespace - -ABSL_FLAG(int, int_flag, 1, ""); -ABSL_FLAG(double, double_flag, 1.1, ""); -ABSL_FLAG(std::string, string_flag, "a", ""); -ABSL_FLAG(bool, bool_flag, false, ""); -ABSL_FLAG(UDT, udt_flag, -1, ""); -ABSL_RETIRED_FLAG(int, legacy_int, 1, ""); -ABSL_RETIRED_FLAG(bool, legacy_bool, false, ""); -ABSL_RETIRED_FLAG(std::string, legacy_str, "l", ""); - -namespace { - -namespace flags = absl::flags_internal; -using testing::ElementsAreArray; - -class ParseTest : public testing::Test { - private: - absl::FlagSaver flag_saver_; -}; - -// -------------------------------------------------------------------- - -template <int N> -std::vector<char*> InvokeParse(const char* (&in_argv)[N]) { - return absl::ParseCommandLine(N, const_cast<char**>(in_argv)); -} - -// -------------------------------------------------------------------- - -template <int N> -void TestParse(const char* (&in_argv)[N], int int_flag_value, - double double_flag_val, absl::string_view string_flag_val, - bool bool_flag_val, int exp_position_args = 0) { - auto out_args = InvokeParse(in_argv); - - EXPECT_EQ(out_args.size(), 1 + exp_position_args); - EXPECT_STREQ(out_args[0], "testbin"); - - EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), int_flag_value); - EXPECT_NEAR(absl::GetFlag(FLAGS_double_flag), double_flag_val, 0.0001); - EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), string_flag_val); - EXPECT_EQ(absl::GetFlag(FLAGS_bool_flag), bool_flag_val); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestEmptyArgv) { - const char* in_argv[] = {"testbin"}; - - auto out_args = InvokeParse(in_argv); - - EXPECT_EQ(out_args.size(), 1); - EXPECT_STREQ(out_args[0], "testbin"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidIntArg) { - const char* in_args1[] = { - "testbin", - "--int_flag=10", - }; - TestParse(in_args1, 10, 1.1, "a", false); - - const char* in_args2[] = { - "testbin", - "-int_flag=020", - }; - TestParse(in_args2, 20, 1.1, "a", false); - - const char* in_args3[] = { - "testbin", - "--int_flag", - "-30", - }; - TestParse(in_args3, -30, 1.1, "a", false); - - const char* in_args4[] = { - "testbin", - "-int_flag", - "0x21", - }; - TestParse(in_args4, 33, 1.1, "a", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidDoubleArg) { - const char* in_args1[] = { - "testbin", - "--double_flag=2.3", - }; - TestParse(in_args1, 1, 2.3, "a", false); - - const char* in_args2[] = { - "testbin", - "--double_flag=0x1.2", - }; - TestParse(in_args2, 1, 1.125, "a", false); - - const char* in_args3[] = { - "testbin", - "--double_flag", - "99.7", - }; - TestParse(in_args3, 1, 99.7, "a", false); - - const char* in_args4[] = { - "testbin", - "--double_flag", - "0x20.1", - }; - TestParse(in_args4, 1, 32.0625, "a", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidStringArg) { - const char* in_args1[] = { - "testbin", - "--string_flag=aqswde", - }; - TestParse(in_args1, 1, 1.1, "aqswde", false); - - const char* in_args2[] = { - "testbin", - "-string_flag=a=b=c", - }; - TestParse(in_args2, 1, 1.1, "a=b=c", false); - - const char* in_args3[] = { - "testbin", - "--string_flag", - "zaxscd", - }; - TestParse(in_args3, 1, 1.1, "zaxscd", false); - - const char* in_args4[] = { - "testbin", - "-string_flag", - "--int_flag", - }; - TestParse(in_args4, 1, 1.1, "--int_flag", false); - - const char* in_args5[] = { - "testbin", - "--string_flag", - "--no_a_flag=11", - }; - TestParse(in_args5, 1, 1.1, "--no_a_flag=11", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidBoolArg) { - const char* in_args1[] = { - "testbin", - "--bool_flag", - }; - TestParse(in_args1, 1, 1.1, "a", true); - - const char* in_args2[] = { - "testbin", - "--nobool_flag", - }; - TestParse(in_args2, 1, 1.1, "a", false); - - const char* in_args3[] = { - "testbin", - "--bool_flag=true", - }; - TestParse(in_args3, 1, 1.1, "a", true); - - const char* in_args4[] = { - "testbin", - "-bool_flag=false", - }; - TestParse(in_args4, 1, 1.1, "a", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidUDTArg) { - const char* in_args1[] = { - "testbin", - "--udt_flag=A", - }; - InvokeParse(in_args1); - - EXPECT_EQ(absl::GetFlag(FLAGS_udt_flag).value, 1); - - const char* in_args2[] = {"testbin", "--udt_flag", "AAA"}; - InvokeParse(in_args2); - - EXPECT_EQ(absl::GetFlag(FLAGS_udt_flag).value, 10); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidMultipleArg) { - const char* in_args1[] = { - "testbin", "--bool_flag", "--int_flag=2", - "--double_flag=0.1", "--string_flag=asd", - }; - TestParse(in_args1, 2, 0.1, "asd", true); - - const char* in_args2[] = { - "testbin", "--string_flag=", "--nobool_flag", "--int_flag", - "-011", "--double_flag", "-1e-2", - }; - TestParse(in_args2, -11, -0.01, "", false); - - const char* in_args3[] = { - "testbin", "--int_flag", "-0", "--string_flag", "\"\"", - "--bool_flag=true", "--double_flag=1e18", - }; - TestParse(in_args3, 0, 1e18, "\"\"", true); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestPositionalArgs) { - const char* in_args1[] = { - "testbin", - "p1", - "p2", - }; - TestParse(in_args1, 1, 1.1, "a", false, 2); - - auto out_args1 = InvokeParse(in_args1); - - EXPECT_STREQ(out_args1[1], "p1"); - EXPECT_STREQ(out_args1[2], "p2"); - - const char* in_args2[] = { - "testbin", - "--int_flag=2", - "p1", - }; - TestParse(in_args2, 2, 1.1, "a", false, 1); - - auto out_args2 = InvokeParse(in_args2); - - EXPECT_STREQ(out_args2[1], "p1"); - - const char* in_args3[] = {"testbin", "p1", "--int_flag=3", - "p2", "--bool_flag", "true"}; - TestParse(in_args3, 3, 1.1, "a", true, 3); - - auto out_args3 = InvokeParse(in_args3); - - EXPECT_STREQ(out_args3[1], "p1"); - EXPECT_STREQ(out_args3[2], "p2"); - EXPECT_STREQ(out_args3[3], "true"); - - const char* in_args4[] = { - "testbin", - "--", - "p1", - "p2", - }; - TestParse(in_args4, 3, 1.1, "a", true, 2); - - auto out_args4 = InvokeParse(in_args4); - - EXPECT_STREQ(out_args4[1], "p1"); - EXPECT_STREQ(out_args4[2], "p2"); - - const char* in_args5[] = { - "testbin", "p1", "--int_flag=4", "--", "--bool_flag", "false", "p2", - }; - TestParse(in_args5, 4, 1.1, "a", true, 4); - - auto out_args5 = InvokeParse(in_args5); - - EXPECT_STREQ(out_args5[1], "p1"); - EXPECT_STREQ(out_args5[2], "--bool_flag"); - EXPECT_STREQ(out_args5[3], "false"); - EXPECT_STREQ(out_args5[4], "p2"); -} - -// -------------------------------------------------------------------- - -using ParseDeathTest = ParseTest; - -TEST_F(ParseDeathTest, TestUndefinedArg) { - const char* in_args1[] = { - "testbin", - "--undefined_flag", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "Unknown command line flag 'undefined_flag'"); - - const char* in_args2[] = { - "testbin", - "--noprefixed_flag", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args2), - "Unknown command line flag 'noprefixed_flag'"); - - const char* in_args3[] = { - "testbin", - "--Int_flag=1", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args3), - "Unknown command line flag 'Int_flag'"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestInvalidBoolFlagFormat) { - const char* in_args1[] = { - "testbin", - "--bool_flag=", - }; - EXPECT_DEATH_IF_SUPPORTED( - InvokeParse(in_args1), - "Missing the value after assignment for the boolean flag 'bool_flag'"); - - const char* in_args2[] = { - "testbin", - "--nobool_flag=true", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args2), - "Negative form with assignment is not valid for the boolean " - "flag 'bool_flag'"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestInvalidNonBoolFlagFormat) { - const char* in_args1[] = { - "testbin", - "--nostring_flag", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "Negative form is not valid for the flag 'string_flag'"); - - const char* in_args2[] = { - "testbin", - "--int_flag", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args2), - "Missing the value for the flag 'int_flag'"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestInvalidUDTFlagFormat) { - const char* in_args1[] = { - "testbin", - "--udt_flag=1", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "Illegal value '1' specified for flag 'udt_flag'; Use values A, " - "AAA instead"); - - const char* in_args2[] = { - "testbin", - "--udt_flag", - "AA", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args2), - "Illegal value 'AA' specified for flag 'udt_flag'; Use values " - "A, AAA instead"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestLegacyFlags) { - const char* in_args1[] = { - "testbin", - "--legacy_int=11", - }; - TestParse(in_args1, 1, 1.1, "a", false); - - const char* in_args2[] = { - "testbin", - "--legacy_bool", - }; - TestParse(in_args2, 1, 1.1, "a", false); - - const char* in_args3[] = { - "testbin", "--legacy_int", "22", "--int_flag=2", - "--legacy_bool", "true", "--legacy_str", "--string_flag=qwe", - }; - TestParse(in_args3, 2, 1.1, "a", false, 1); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestSimpleValidFlagfile) { - std::string flagfile_flag; - - const char* in_args1[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff1", absl::MakeConstSpan(ff1_data)}}, - flagfile_flag), - }; - TestParse(in_args1, -1, 0.1, "q2w2 ", true); - - const char* in_args2[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff2", absl::MakeConstSpan(ff2_data)}}, - flagfile_flag), - }; - TestParse(in_args2, 100, 0.1, "q2w2 ", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestValidMultiFlagfile) { - std::string flagfile_flag; - - const char* in_args1[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff2", absl::MakeConstSpan(ff2_data)}, - {"parse_test.ff1", absl::MakeConstSpan(ff1_data)}}, - flagfile_flag), - }; - TestParse(in_args1, -1, 0.1, "q2w2 ", true); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestFlagfileMixedWithRegularFlags) { - std::string flagfile_flag; - - const char* in_args1[] = { - "testbin", "--int_flag=3", - GetFlagfileFlag({{"parse_test.ff1", absl::MakeConstSpan(ff1_data)}}, - flagfile_flag), - "-double_flag=0.2"}; - TestParse(in_args1, -1, 0.2, "q2w2 ", true); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestFlagfileInFlagfile) { - std::string flagfile_flag; - - constexpr const char* const ff3_data[] = { - "--flagfile=$0/parse_test.ff1", - "--flagfile=$0/parse_test.ff2", - }; - - GetFlagfileFlag({{"parse_test.ff2", absl::MakeConstSpan(ff2_data)}, - {"parse_test.ff1", absl::MakeConstSpan(ff1_data)}}, - flagfile_flag); - - const char* in_args1[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff3", absl::MakeConstSpan(ff3_data)}}, - flagfile_flag), - }; - TestParse(in_args1, 100, 0.1, "q2w2 ", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestInvalidFlagfiles) { - std::string flagfile_flag; - - constexpr const char* const ff4_data[] = { - "--unknown_flag=10" - }; - - const char* in_args1[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff4", - absl::MakeConstSpan(ff4_data)}}, flagfile_flag), - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "Unknown command line flag 'unknown_flag'"); - - constexpr const char* const ff5_data[] = { - "--int_flag 10", - }; - - const char* in_args2[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff5", - absl::MakeConstSpan(ff5_data)}}, flagfile_flag), - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args2), - "Unknown command line flag 'int_flag 10'"); - - constexpr const char* const ff6_data[] = { - "--int_flag=10", "--", "arg1", "arg2", "arg3", - }; - - const char* in_args3[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff6", absl::MakeConstSpan(ff6_data)}}, - flagfile_flag), - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args3), - "Flagfile can't contain position arguments or --"); - - const char* in_args4[] = { - "testbin", - "--flagfile=invalid_flag_file", - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args4), - "Can't open flagfile invalid_flag_file"); - - constexpr const char* const ff7_data[] = { - "--int_flag=10", - "*bin*", - "--str_flag=aqsw", - }; - - const char* in_args5[] = { - "testbin", - GetFlagfileFlag({{"parse_test.ff7", absl::MakeConstSpan(ff7_data)}}, - flagfile_flag), - }; - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args5), - "Unexpected line in the flagfile .*: \\*bin\\*"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestReadingRequiredFlagsFromEnv) { - const char* in_args1[] = {"testbin", - "--fromenv=int_flag,bool_flag,string_flag"}; - - ScopedSetEnv set_int_flag("FLAGS_int_flag", "33"); - ScopedSetEnv set_bool_flag("FLAGS_bool_flag", "True"); - ScopedSetEnv set_string_flag("FLAGS_string_flag", "AQ12"); - - TestParse(in_args1, 33, 1.1, "AQ12", true); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestReadingUnsetRequiredFlagsFromEnv) { - const char* in_args1[] = {"testbin", "--fromenv=int_flag"}; - - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "FLAGS_int_flag not found in environment"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestRecursiveFlagsFromEnv) { - const char* in_args1[] = {"testbin", "--fromenv=tryfromenv"}; - - ScopedSetEnv set_tryfromenv("FLAGS_tryfromenv", "int_flag"); - - EXPECT_DEATH_IF_SUPPORTED(InvokeParse(in_args1), - "Infinite recursion on flag tryfromenv"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestReadingOptionalFlagsFromEnv) { - const char* in_args1[] = { - "testbin", "--tryfromenv=int_flag,bool_flag,string_flag,other_flag"}; - - ScopedSetEnv set_int_flag("FLAGS_int_flag", "17"); - ScopedSetEnv set_bool_flag("FLAGS_bool_flag", "Y"); - - TestParse(in_args1, 17, 1.1, "a", true); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestReadingFlagsFromEnvMoxedWithRegularFlags) { - const char* in_args1[] = { - "testbin", - "--bool_flag=T", - "--tryfromenv=int_flag,bool_flag", - "--int_flag=-21", - }; - - ScopedSetEnv set_int_flag("FLAGS_int_flag", "-15"); - ScopedSetEnv set_bool_flag("FLAGS_bool_flag", "F"); - - TestParse(in_args1, -21, 1.1, "a", false); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestKeepParsedArgs) { - const char* in_args1[] = { - "testbin", "arg1", "--bool_flag", - "--int_flag=211", "arg2", "--double_flag=1.1", - "--string_flag", "asd", "--", - "arg3", "arg4", - }; - - auto out_args1 = InvokeParse(in_args1); - - EXPECT_THAT( - out_args1, - ElementsAreArray({absl::string_view("testbin"), absl::string_view("arg1"), - absl::string_view("arg2"), absl::string_view("arg3"), - absl::string_view("arg4")})); - - auto out_args2 = flags::ParseCommandLineImpl( - 11, const_cast<char**>(in_args1), flags::ArgvListAction::kKeepParsedArgs, - flags::UsageFlagsAction::kHandleUsage, - flags::OnUndefinedFlag::kAbortIfUndefined); - - EXPECT_THAT( - out_args2, - ElementsAreArray({absl::string_view("testbin"), - absl::string_view("--bool_flag"), - absl::string_view("--int_flag=211"), - absl::string_view("--double_flag=1.1"), - absl::string_view("--string_flag"), - absl::string_view("asd"), absl::string_view("--"), - absl::string_view("arg1"), absl::string_view("arg2"), - absl::string_view("arg3"), absl::string_view("arg4")})); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, TestIgnoreUndefinedFlags) { - const char* in_args1[] = { - "testbin", - "arg1", - "--undef_flag=aa", - "--int_flag=21", - }; - - auto out_args1 = flags::ParseCommandLineImpl( - 4, const_cast<char**>(in_args1), flags::ArgvListAction::kRemoveParsedArgs, - flags::UsageFlagsAction::kHandleUsage, - flags::OnUndefinedFlag::kIgnoreUndefined); - - EXPECT_THAT(out_args1, ElementsAreArray({absl::string_view("testbin"), - absl::string_view("arg1")})); - - EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 21); - - const char* in_args2[] = { - "testbin", - "arg1", - "--undef_flag=aa", - "--string_flag=AA", - }; - - auto out_args2 = flags::ParseCommandLineImpl( - 4, const_cast<char**>(in_args2), flags::ArgvListAction::kKeepParsedArgs, - flags::UsageFlagsAction::kHandleUsage, - flags::OnUndefinedFlag::kIgnoreUndefined); - - EXPECT_THAT( - out_args2, - ElementsAreArray( - {absl::string_view("testbin"), absl::string_view("--undef_flag=aa"), - absl::string_view("--string_flag=AA"), absl::string_view("arg1")})); - - EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "AA"); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseDeathTest, TestHelpFlagHandling) { - const char* in_args1[] = { - "testbin", - "--help", - }; - - EXPECT_EXIT(InvokeParse(in_args1), testing::ExitedWithCode(1), ""); - - const char* in_args2[] = { - "testbin", - "--help", - "--int_flag=3", - }; - - auto out_args2 = flags::ParseCommandLineImpl( - 3, const_cast<char**>(in_args2), flags::ArgvListAction::kRemoveParsedArgs, - flags::UsageFlagsAction::kIgnoreUsage, - flags::OnUndefinedFlag::kAbortIfUndefined); - - EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 3); -} - -// -------------------------------------------------------------------- - -TEST_F(ParseTest, WasPresentOnCommandLine) { - const char* in_args1[] = { - "testbin", "arg1", "--bool_flag", - "--int_flag=211", "arg2", "--double_flag=1.1", - "--string_flag", "asd", "--", - "--some_flag", "arg4", - }; - - InvokeParse(in_args1); - - EXPECT_TRUE(flags::WasPresentOnCommandLine("bool_flag")); - EXPECT_TRUE(flags::WasPresentOnCommandLine("int_flag")); - EXPECT_TRUE(flags::WasPresentOnCommandLine("double_flag")); - EXPECT_TRUE(flags::WasPresentOnCommandLine("string_flag")); - EXPECT_FALSE(flags::WasPresentOnCommandLine("some_flag")); - EXPECT_FALSE(flags::WasPresentOnCommandLine("another_flag")); -} - -// -------------------------------------------------------------------- - -} // namespace |