commandlineflag_test.cc (8500B)
1 // 2 // Copyright 2019 The Abseil Authors. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // https://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 16 #include "absl/flags/commandlineflag.h" 17 18 #include <memory> 19 #include <string> 20 21 #include "gtest/gtest.h" 22 #include "absl/flags/config.h" 23 #include "absl/flags/flag.h" 24 #include "absl/flags/internal/private_handle_accessor.h" 25 #include "absl/flags/reflection.h" 26 #include "absl/flags/usage_config.h" 27 #include "absl/memory/memory.h" 28 #include "absl/strings/match.h" 29 #include "absl/strings/str_cat.h" 30 #include "absl/strings/string_view.h" 31 32 ABSL_FLAG(int, int_flag, 201, "int_flag help"); 33 ABSL_FLAG(std::string, string_flag, "dflt", 34 absl::StrCat("string_flag", " help")); 35 ABSL_RETIRED_FLAG(bool, bool_retired_flag, false, "bool_retired_flag help"); 36 37 // These are only used to test default values. 38 ABSL_FLAG(int, int_flag2, 201, ""); 39 ABSL_FLAG(std::string, string_flag2, "dflt", ""); 40 41 namespace { 42 43 namespace flags = absl::flags_internal; 44 45 class CommandLineFlagTest : public testing::Test { 46 protected: 47 static void SetUpTestSuite() { 48 // Install a function to normalize filenames before this test is run. 49 absl::FlagsUsageConfig default_config; 50 default_config.normalize_filename = &CommandLineFlagTest::NormalizeFileName; 51 absl::SetFlagsUsageConfig(default_config); 52 } 53 54 void SetUp() override { 55 #if ABSL_FLAGS_STRIP_NAMES 56 GTEST_SKIP() << "This test requires flag names to be present"; 57 #endif 58 flag_saver_ = absl::make_unique<absl::FlagSaver>(); 59 } 60 void TearDown() override { flag_saver_.reset(); } 61 62 private: 63 static std::string NormalizeFileName(absl::string_view fname) { 64 #ifdef _WIN32 65 std::string normalized(fname); 66 std::replace(normalized.begin(), normalized.end(), '\\', '/'); 67 fname = normalized; 68 #endif 69 return std::string(fname); 70 } 71 72 std::unique_ptr<absl::FlagSaver> flag_saver_; 73 }; 74 75 TEST_F(CommandLineFlagTest, TestAttributesAccessMethods) { 76 auto* flag_01 = absl::FindCommandLineFlag("int_flag"); 77 78 ASSERT_TRUE(flag_01); 79 EXPECT_EQ(flag_01->Name(), "int_flag"); 80 EXPECT_EQ(flag_01->Help(), "int_flag help"); 81 EXPECT_TRUE(!flag_01->IsRetired()); 82 EXPECT_TRUE(flag_01->IsOfType<int>()); 83 EXPECT_TRUE(!flag_01->IsOfType<bool>()); 84 EXPECT_TRUE(!flag_01->IsOfType<std::string>()); 85 EXPECT_TRUE(absl::EndsWith(flag_01->Filename(), 86 "absl/flags/commandlineflag_test.cc")) 87 << flag_01->Filename(); 88 89 auto* flag_02 = absl::FindCommandLineFlag("string_flag"); 90 91 ASSERT_TRUE(flag_02); 92 EXPECT_EQ(flag_02->Name(), "string_flag"); 93 EXPECT_EQ(flag_02->Help(), "string_flag help"); 94 EXPECT_TRUE(!flag_02->IsRetired()); 95 EXPECT_TRUE(flag_02->IsOfType<std::string>()); 96 EXPECT_TRUE(!flag_02->IsOfType<bool>()); 97 EXPECT_TRUE(!flag_02->IsOfType<int>()); 98 EXPECT_TRUE(absl::EndsWith(flag_02->Filename(), 99 "absl/flags/commandlineflag_test.cc")) 100 << flag_02->Filename(); 101 } 102 103 // -------------------------------------------------------------------- 104 105 TEST_F(CommandLineFlagTest, TestValueAccessMethods) { 106 absl::SetFlag(&FLAGS_int_flag2, 301); 107 auto* flag_01 = absl::FindCommandLineFlag("int_flag2"); 108 109 ASSERT_TRUE(flag_01); 110 EXPECT_EQ(flag_01->CurrentValue(), "301"); 111 EXPECT_EQ(flag_01->DefaultValue(), "201"); 112 113 absl::SetFlag(&FLAGS_string_flag2, "new_str_value"); 114 auto* flag_02 = absl::FindCommandLineFlag("string_flag2"); 115 116 ASSERT_TRUE(flag_02); 117 EXPECT_EQ(flag_02->CurrentValue(), "new_str_value"); 118 EXPECT_EQ(flag_02->DefaultValue(), "dflt"); 119 } 120 121 // -------------------------------------------------------------------- 122 123 TEST_F(CommandLineFlagTest, TestParseFromCurrentValue) { 124 std::string err; 125 126 auto* flag_01 = absl::FindCommandLineFlag("int_flag"); 127 EXPECT_FALSE( 128 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 129 130 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 131 *flag_01, "11", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, err)); 132 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11); 133 EXPECT_FALSE( 134 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 135 136 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 137 *flag_01, "-123", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, 138 err)); 139 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); 140 EXPECT_FALSE( 141 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 142 143 EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom( 144 *flag_01, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, 145 err)); 146 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); 147 EXPECT_EQ(err, "Illegal value 'xyz' specified for flag 'int_flag'"); 148 EXPECT_FALSE( 149 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 150 151 EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom( 152 *flag_01, "A1", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, err)); 153 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), -123); 154 EXPECT_EQ(err, "Illegal value 'A1' specified for flag 'int_flag'"); 155 EXPECT_FALSE( 156 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 157 158 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 159 *flag_01, "0x10", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, 160 err)); 161 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 16); 162 EXPECT_FALSE( 163 flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 164 165 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 166 *flag_01, "011", flags::SET_FLAGS_VALUE, flags::kCommandLine, err)); 167 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 11); 168 EXPECT_TRUE(flags::PrivateHandleAccessor::IsSpecifiedOnCommandLine(*flag_01)); 169 170 EXPECT_TRUE(!flags::PrivateHandleAccessor::ParseFrom( 171 *flag_01, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, err)); 172 EXPECT_EQ(err, "Illegal value '' specified for flag 'int_flag'"); 173 174 auto* flag_02 = absl::FindCommandLineFlag("string_flag"); 175 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 176 *flag_02, "xyz", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, 177 err)); 178 EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), "xyz"); 179 180 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 181 *flag_02, "", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, err)); 182 EXPECT_EQ(absl::GetFlag(FLAGS_string_flag), ""); 183 } 184 185 // -------------------------------------------------------------------- 186 187 TEST_F(CommandLineFlagTest, TestParseFromDefaultValue) { 188 std::string err; 189 190 auto* flag_01 = absl::FindCommandLineFlag("int_flag"); 191 192 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 193 *flag_01, "111", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange, 194 err)); 195 EXPECT_EQ(flag_01->DefaultValue(), "111"); 196 197 auto* flag_02 = absl::FindCommandLineFlag("string_flag"); 198 199 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 200 *flag_02, "abc", flags::SET_FLAGS_DEFAULT, flags::kProgrammaticChange, 201 err)); 202 EXPECT_EQ(flag_02->DefaultValue(), "abc"); 203 } 204 205 // -------------------------------------------------------------------- 206 207 TEST_F(CommandLineFlagTest, TestParseFromIfDefault) { 208 std::string err; 209 210 auto* flag_01 = absl::FindCommandLineFlag("int_flag"); 211 212 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 213 *flag_01, "22", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, 214 err)) 215 << err; 216 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22); 217 218 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 219 *flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, 220 err)); 221 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 22); 222 // EXPECT_EQ(err, "ERROR: int_flag is already set to 22"); 223 224 // Reset back to default value 225 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 226 *flag_01, "201", flags::SET_FLAGS_VALUE, flags::kProgrammaticChange, 227 err)); 228 229 EXPECT_TRUE(flags::PrivateHandleAccessor::ParseFrom( 230 *flag_01, "33", flags::SET_FLAG_IF_DEFAULT, flags::kProgrammaticChange, 231 err)); 232 EXPECT_EQ(absl::GetFlag(FLAGS_int_flag), 201); 233 // EXPECT_EQ(err, "ERROR: int_flag is already set to 201"); 234 } 235 236 } // namespace