reflection_test.cc (9327B)
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/reflection.h" 17 18 #include <memory> 19 #include <string> 20 21 #include "gmock/gmock.h" 22 #include "gtest/gtest.h" 23 #include "absl/flags/config.h" 24 #include "absl/flags/flag.h" 25 #include "absl/memory/memory.h" 26 #include "absl/strings/str_cat.h" 27 #include "absl/strings/str_split.h" 28 29 ABSL_FLAG(int, int_flag, 1, "int_flag help"); 30 ABSL_FLAG(std::string, string_flag, "dflt", "string_flag help"); 31 ABSL_RETIRED_FLAG(bool, bool_retired_flag, false, "bool_retired_flag help"); 32 33 namespace { 34 35 class ReflectionTest : public testing::Test { 36 protected: 37 void SetUp() override { 38 #if ABSL_FLAGS_STRIP_NAMES 39 GTEST_SKIP() << "This test requires flag names to be present"; 40 #endif 41 flag_saver_ = absl::make_unique<absl::FlagSaver>(); 42 } 43 void TearDown() override { flag_saver_.reset(); } 44 45 private: 46 std::unique_ptr<absl::FlagSaver> flag_saver_; 47 }; 48 49 // -------------------------------------------------------------------- 50 51 TEST_F(ReflectionTest, TestFindCommandLineFlag) { 52 auto* handle = absl::FindCommandLineFlag("some_flag"); 53 EXPECT_EQ(handle, nullptr); 54 55 handle = absl::FindCommandLineFlag("int_flag"); 56 EXPECT_NE(handle, nullptr); 57 58 handle = absl::FindCommandLineFlag("string_flag"); 59 EXPECT_NE(handle, nullptr); 60 61 handle = absl::FindCommandLineFlag("bool_retired_flag"); 62 EXPECT_NE(handle, nullptr); 63 } 64 65 // -------------------------------------------------------------------- 66 67 TEST_F(ReflectionTest, TestGetAllFlags) { 68 auto all_flags = absl::GetAllFlags(); 69 EXPECT_NE(all_flags.find("int_flag"), all_flags.end()); 70 EXPECT_EQ(all_flags.find("bool_retired_flag"), all_flags.end()); 71 EXPECT_EQ(all_flags.find("some_undefined_flag"), all_flags.end()); 72 73 std::vector<absl::string_view> flag_names_first_attempt; 74 auto all_flags_1 = absl::GetAllFlags(); 75 for (auto f : all_flags_1) { 76 flag_names_first_attempt.push_back(f.first); 77 } 78 79 std::vector<absl::string_view> flag_names_second_attempt; 80 auto all_flags_2 = absl::GetAllFlags(); 81 for (auto f : all_flags_2) { 82 flag_names_second_attempt.push_back(f.first); 83 } 84 85 EXPECT_THAT(flag_names_first_attempt, 86 ::testing::UnorderedElementsAreArray(flag_names_second_attempt)); 87 } 88 89 // -------------------------------------------------------------------- 90 91 struct CustomUDT { 92 CustomUDT() : a(1), b(1) {} 93 CustomUDT(int a_, int b_) : a(a_), b(b_) {} 94 95 friend bool operator==(const CustomUDT& f1, const CustomUDT& f2) { 96 return f1.a == f2.a && f1.b == f2.b; 97 } 98 99 int a; 100 int b; 101 }; 102 bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) { 103 std::vector<absl::string_view> parts = 104 absl::StrSplit(in, ':', absl::SkipWhitespace()); 105 106 if (parts.size() != 2) return false; 107 108 if (!absl::SimpleAtoi(parts[0], &f->a)) return false; 109 110 if (!absl::SimpleAtoi(parts[1], &f->b)) return false; 111 112 return true; 113 } 114 std::string AbslUnparseFlag(const CustomUDT& f) { 115 return absl::StrCat(f.a, ":", f.b); 116 } 117 118 } // namespace 119 120 // -------------------------------------------------------------------- 121 122 ABSL_FLAG(bool, test_flag_01, true, ""); 123 ABSL_FLAG(int, test_flag_02, 1234, ""); 124 ABSL_FLAG(int16_t, test_flag_03, -34, ""); 125 ABSL_FLAG(uint16_t, test_flag_04, 189, ""); 126 ABSL_FLAG(int32_t, test_flag_05, 10765, ""); 127 ABSL_FLAG(uint32_t, test_flag_06, 40000, ""); 128 ABSL_FLAG(int64_t, test_flag_07, -1234567, ""); 129 ABSL_FLAG(uint64_t, test_flag_08, 9876543, ""); 130 ABSL_FLAG(double, test_flag_09, -9.876e-50, ""); 131 ABSL_FLAG(float, test_flag_10, 1.234e12f, ""); 132 ABSL_FLAG(std::string, test_flag_11, "", ""); 133 ABSL_FLAG(absl::Duration, test_flag_12, absl::Minutes(10), ""); 134 static int counter = 0; 135 ABSL_FLAG(int, test_flag_13, 200, "").OnUpdate([]() { counter++; }); 136 ABSL_FLAG(CustomUDT, test_flag_14, {}, ""); 137 138 namespace { 139 140 TEST_F(ReflectionTest, TestFlagSaverInScope) { 141 { 142 absl::FlagSaver s; 143 counter = 0; 144 absl::SetFlag(&FLAGS_test_flag_01, false); 145 absl::SetFlag(&FLAGS_test_flag_02, -1021); 146 absl::SetFlag(&FLAGS_test_flag_03, 6009); 147 absl::SetFlag(&FLAGS_test_flag_04, 44); 148 absl::SetFlag(&FLAGS_test_flag_05, +800); 149 absl::SetFlag(&FLAGS_test_flag_06, -40978756); 150 absl::SetFlag(&FLAGS_test_flag_07, 23405); 151 absl::SetFlag(&FLAGS_test_flag_08, 975310); 152 absl::SetFlag(&FLAGS_test_flag_09, 1.00001); 153 absl::SetFlag(&FLAGS_test_flag_10, -3.54f); 154 absl::SetFlag(&FLAGS_test_flag_11, "asdf"); 155 absl::SetFlag(&FLAGS_test_flag_12, absl::Hours(20)); 156 absl::SetFlag(&FLAGS_test_flag_13, 4); 157 absl::SetFlag(&FLAGS_test_flag_14, CustomUDT{-1, -2}); 158 } 159 160 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true); 161 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234); 162 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34); 163 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189); 164 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765); 165 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000); 166 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567); 167 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543); 168 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55); 169 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f); 170 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), ""); 171 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10)); 172 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), 200); 173 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14), CustomUDT{}); 174 EXPECT_EQ(counter, 2); 175 } 176 177 // -------------------------------------------------------------------- 178 179 TEST_F(ReflectionTest, TestFlagSaverVsUpdateViaReflection) { 180 { 181 absl::FlagSaver s; 182 counter = 0; 183 std::string error; 184 EXPECT_TRUE( 185 absl::FindCommandLineFlag("test_flag_01")->ParseFrom("false", &error)) 186 << error; 187 EXPECT_TRUE( 188 absl::FindCommandLineFlag("test_flag_02")->ParseFrom("-4536", &error)) 189 << error; 190 EXPECT_TRUE( 191 absl::FindCommandLineFlag("test_flag_03")->ParseFrom("111", &error)) 192 << error; 193 EXPECT_TRUE( 194 absl::FindCommandLineFlag("test_flag_04")->ParseFrom("909", &error)) 195 << error; 196 EXPECT_TRUE( 197 absl::FindCommandLineFlag("test_flag_05")->ParseFrom("-2004", &error)) 198 << error; 199 EXPECT_TRUE( 200 absl::FindCommandLineFlag("test_flag_06")->ParseFrom("1000023", &error)) 201 << error; 202 EXPECT_TRUE( 203 absl::FindCommandLineFlag("test_flag_07")->ParseFrom("69305", &error)) 204 << error; 205 EXPECT_TRUE(absl::FindCommandLineFlag("test_flag_08") 206 ->ParseFrom("1000000001", &error)) 207 << error; 208 EXPECT_TRUE( 209 absl::FindCommandLineFlag("test_flag_09")->ParseFrom("2.09021", &error)) 210 << error; 211 EXPECT_TRUE( 212 absl::FindCommandLineFlag("test_flag_10")->ParseFrom("-33.1", &error)) 213 << error; 214 EXPECT_TRUE( 215 absl::FindCommandLineFlag("test_flag_11")->ParseFrom("ADD_FOO", &error)) 216 << error; 217 EXPECT_TRUE(absl::FindCommandLineFlag("test_flag_12") 218 ->ParseFrom("3h11m16s", &error)) 219 << error; 220 EXPECT_TRUE( 221 absl::FindCommandLineFlag("test_flag_13")->ParseFrom("0", &error)) 222 << error; 223 EXPECT_TRUE( 224 absl::FindCommandLineFlag("test_flag_14")->ParseFrom("10:1", &error)) 225 << error; 226 } 227 228 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true); 229 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234); 230 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34); 231 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189); 232 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765); 233 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000); 234 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567); 235 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543); 236 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55); 237 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f); 238 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), ""); 239 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10)); 240 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), 200); 241 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14), CustomUDT{}); 242 EXPECT_EQ(counter, 2); 243 } 244 245 // -------------------------------------------------------------------- 246 247 TEST_F(ReflectionTest, TestMultipleFlagSaversInEnclosedScopes) { 248 { 249 absl::FlagSaver s; 250 absl::SetFlag(&FLAGS_test_flag_08, 10); 251 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 10); 252 { 253 absl::FlagSaver s; 254 absl::SetFlag(&FLAGS_test_flag_08, 20); 255 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 20); 256 { 257 absl::FlagSaver s; 258 absl::SetFlag(&FLAGS_test_flag_08, -200); 259 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), -200); 260 } 261 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 20); 262 } 263 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 10); 264 } 265 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543); 266 } 267 268 } // namespace