abseil-cpp/absl/flags/reflection_test.cc
Go to the documentation of this file.
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/declare.h"
24 #include "absl/flags/flag.h"
25 #include "absl/flags/internal/commandlineflag.h"
26 #include "absl/flags/marshalling.h"
27 #include "absl/memory/memory.h"
28 #include "absl/strings/str_cat.h"
29 #include "absl/strings/str_split.h"
30 
31 ABSL_FLAG(int, int_flag, 1, "int_flag help");
32 ABSL_FLAG(std::string, string_flag, "dflt", "string_flag help");
33 ABSL_RETIRED_FLAG(bool, bool_retired_flag, false, "bool_retired_flag help");
34 
35 namespace {
36 
37 class ReflectionTest : public testing::Test {
38  protected:
39  void SetUp() override { flag_saver_ = absl::make_unique<absl::FlagSaver>(); }
40  void TearDown() override { flag_saver_.reset(); }
41 
42  private:
43  std::unique_ptr<absl::FlagSaver> flag_saver_;
44 };
45 
46 // --------------------------------------------------------------------
47 
48 TEST_F(ReflectionTest, TestFindCommandLineFlag) {
49  auto* handle = absl::FindCommandLineFlag("some_flag");
50  EXPECT_EQ(handle, nullptr);
51 
52  handle = absl::FindCommandLineFlag("int_flag");
53  EXPECT_NE(handle, nullptr);
54 
55  handle = absl::FindCommandLineFlag("string_flag");
56  EXPECT_NE(handle, nullptr);
57 
58  handle = absl::FindCommandLineFlag("bool_retired_flag");
59  EXPECT_NE(handle, nullptr);
60 }
61 
62 // --------------------------------------------------------------------
63 
64 TEST_F(ReflectionTest, TestGetAllFlags) {
65  auto all_flags = absl::GetAllFlags();
66  EXPECT_NE(all_flags.find("int_flag"), all_flags.end());
67  EXPECT_EQ(all_flags.find("bool_retired_flag"), all_flags.end());
68  EXPECT_EQ(all_flags.find("some_undefined_flag"), all_flags.end());
69 
70  std::vector<absl::string_view> flag_names_first_attempt;
71  auto all_flags_1 = absl::GetAllFlags();
72  for (auto f : all_flags_1) {
73  flag_names_first_attempt.push_back(f.first);
74  }
75 
76  std::vector<absl::string_view> flag_names_second_attempt;
77  auto all_flags_2 = absl::GetAllFlags();
78  for (auto f : all_flags_2) {
79  flag_names_second_attempt.push_back(f.first);
80  }
81 
82  EXPECT_THAT(flag_names_first_attempt,
83  ::testing::UnorderedElementsAreArray(flag_names_second_attempt));
84 }
85 
86 // --------------------------------------------------------------------
87 
88 struct CustomUDT {
89  CustomUDT() : a(1), b(1) {}
90  CustomUDT(int a_, int b_) : a(a_), b(b_) {}
91 
92  friend bool operator==(const CustomUDT& f1, const CustomUDT& f2) {
93  return f1.a == f2.a && f1.b == f2.b;
94  }
95 
96  int a;
97  int b;
98 };
99 bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) {
100  std::vector<absl::string_view> parts =
101  absl::StrSplit(in, ':', absl::SkipWhitespace());
102 
103  if (parts.size() != 2) return false;
104 
105  if (!absl::SimpleAtoi(parts[0], &f->a)) return false;
106 
107  if (!absl::SimpleAtoi(parts[1], &f->b)) return false;
108 
109  return true;
110 }
111 std::string AbslUnparseFlag(const CustomUDT& f) {
112  return absl::StrCat(f.a, ":", f.b);
113 }
114 
115 } // namespace
116 
117 // --------------------------------------------------------------------
118 
119 ABSL_FLAG(bool, test_flag_01, true, "");
120 ABSL_FLAG(int, test_flag_02, 1234, "");
121 ABSL_FLAG(int16_t, test_flag_03, -34, "");
122 ABSL_FLAG(uint16_t, test_flag_04, 189, "");
123 ABSL_FLAG(int32_t, test_flag_05, 10765, "");
124 ABSL_FLAG(uint32_t, test_flag_06, 40000, "");
125 ABSL_FLAG(int64_t, test_flag_07, -1234567, "");
126 ABSL_FLAG(uint64_t, test_flag_08, 9876543, "");
127 ABSL_FLAG(double, test_flag_09, -9.876e-50, "");
128 ABSL_FLAG(float, test_flag_10, 1.234e12f, "");
129 ABSL_FLAG(std::string, test_flag_11, "", "");
130 ABSL_FLAG(absl::Duration, test_flag_12, absl::Minutes(10), "");
131 static int counter = 0;
132 ABSL_FLAG(int, test_flag_13, 200, "").OnUpdate([]() { counter++; });
133 ABSL_FLAG(CustomUDT, test_flag_14, {}, "");
134 
135 namespace {
136 
137 TEST_F(ReflectionTest, TestFlagSaverInScope) {
138  {
139  absl::FlagSaver s;
140  counter = 0;
141  absl::SetFlag(&FLAGS_test_flag_01, false);
142  absl::SetFlag(&FLAGS_test_flag_02, -1021);
143  absl::SetFlag(&FLAGS_test_flag_03, 6009);
144  absl::SetFlag(&FLAGS_test_flag_04, 44);
145  absl::SetFlag(&FLAGS_test_flag_05, +800);
146  absl::SetFlag(&FLAGS_test_flag_06, -40978756);
147  absl::SetFlag(&FLAGS_test_flag_07, 23405);
148  absl::SetFlag(&FLAGS_test_flag_08, 975310);
149  absl::SetFlag(&FLAGS_test_flag_09, 1.00001);
150  absl::SetFlag(&FLAGS_test_flag_10, -3.54f);
151  absl::SetFlag(&FLAGS_test_flag_11, "asdf");
152  absl::SetFlag(&FLAGS_test_flag_12, absl::Hours(20));
153  absl::SetFlag(&FLAGS_test_flag_13, 4);
154  absl::SetFlag(&FLAGS_test_flag_14, CustomUDT{-1, -2});
155  }
156 
157  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true);
158  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234);
159  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34);
160  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189);
161  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765);
162  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000);
163  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567);
164  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
165  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55);
166  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f);
167  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "");
168  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10));
169  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), 200);
170  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14), CustomUDT{});
171  EXPECT_EQ(counter, 2);
172 }
173 
174 // --------------------------------------------------------------------
175 
176 TEST_F(ReflectionTest, TestFlagSaverVsUpdateViaReflection) {
177  {
178  absl::FlagSaver s;
179  counter = 0;
180  std::string error;
181  EXPECT_TRUE(
182  absl::FindCommandLineFlag("test_flag_01")->ParseFrom("false", &error))
183  << error;
184  EXPECT_TRUE(
185  absl::FindCommandLineFlag("test_flag_02")->ParseFrom("-4536", &error))
186  << error;
187  EXPECT_TRUE(
188  absl::FindCommandLineFlag("test_flag_03")->ParseFrom("111", &error))
189  << error;
190  EXPECT_TRUE(
191  absl::FindCommandLineFlag("test_flag_04")->ParseFrom("909", &error))
192  << error;
193  EXPECT_TRUE(
194  absl::FindCommandLineFlag("test_flag_05")->ParseFrom("-2004", &error))
195  << error;
196  EXPECT_TRUE(
197  absl::FindCommandLineFlag("test_flag_06")->ParseFrom("1000023", &error))
198  << error;
199  EXPECT_TRUE(
200  absl::FindCommandLineFlag("test_flag_07")->ParseFrom("69305", &error))
201  << error;
202  EXPECT_TRUE(absl::FindCommandLineFlag("test_flag_08")
203  ->ParseFrom("1000000001", &error))
204  << error;
205  EXPECT_TRUE(
206  absl::FindCommandLineFlag("test_flag_09")->ParseFrom("2.09021", &error))
207  << error;
208  EXPECT_TRUE(
209  absl::FindCommandLineFlag("test_flag_10")->ParseFrom("-33.1", &error))
210  << error;
211  EXPECT_TRUE(
212  absl::FindCommandLineFlag("test_flag_11")->ParseFrom("ADD_FOO", &error))
213  << error;
214  EXPECT_TRUE(absl::FindCommandLineFlag("test_flag_12")
215  ->ParseFrom("3h11m16s", &error))
216  << error;
217  EXPECT_TRUE(
218  absl::FindCommandLineFlag("test_flag_13")->ParseFrom("0", &error))
219  << error;
220  EXPECT_TRUE(
221  absl::FindCommandLineFlag("test_flag_14")->ParseFrom("10:1", &error))
222  << error;
223  }
224 
225  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true);
226  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234);
227  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34);
228  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189);
229  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765);
230  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000);
231  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567);
232  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
233  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55);
234  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f);
235  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "");
236  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10));
237  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), 200);
238  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14), CustomUDT{});
239  EXPECT_EQ(counter, 2);
240 }
241 
242 // --------------------------------------------------------------------
243 
244 TEST_F(ReflectionTest, TestMultipleFlagSaversInEnclosedScopes) {
245  {
246  absl::FlagSaver s;
247  absl::SetFlag(&FLAGS_test_flag_08, 10);
248  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 10);
249  {
250  absl::FlagSaver s;
251  absl::SetFlag(&FLAGS_test_flag_08, 20);
252  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 20);
253  {
254  absl::FlagSaver s;
255  absl::SetFlag(&FLAGS_test_flag_08, -200);
256  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), -200);
257  }
258  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 20);
259  }
260  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 10);
261  }
262  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
263 }
264 
265 } // namespace
absl::StrSplit
strings_internal::Splitter< typename strings_internal::SelectDelimiter< Delimiter >::type, AllowEmpty, absl::string_view > StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d)
Definition: abseil-cpp/absl/strings/str_split.h:499
absl::SetFlag
void SetFlag(absl::Flag< T > *flag, const T &v)
Definition: abseil-cpp/absl/flags/flag.h:110
grpc_event_engine::experimental::slice_detail::operator==
bool operator==(const BaseSlice &a, const BaseSlice &b)
Definition: include/grpc/event_engine/slice.h:117
absl::StrCat
std::string StrCat(const AlphaNum &a, const AlphaNum &b)
Definition: abseil-cpp/absl/strings/str_cat.cc:98
EXPECT_THAT
#define EXPECT_THAT(value, matcher)
uint16_t
unsigned short uint16_t
Definition: stdint-msvc2008.h:79
xds_manager.f1
f1
Definition: xds_manager.py:42
absl::string_view
Definition: abseil-cpp/absl/strings/string_view.h:167
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
error
grpc_error_handle error
Definition: retry_filter.cc:499
absl::FindCommandLineFlag
CommandLineFlag * FindCommandLineFlag(absl::string_view name)
Definition: abseil-cpp/absl/flags/reflection.cc:336
absl::FormatConversionChar::s
@ s
a
int a
Definition: abseil-cpp/absl/container/internal/hash_policy_traits_test.cc:88
testing::Test
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:402
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
testing::Test::TearDown
virtual void TearDown()
Definition: bloaty/third_party/googletest/googletest/src/gtest.cc:2270
uint32_t
unsigned int uint32_t
Definition: stdint-msvc2008.h:80
absl::SimpleAtoi
ABSL_NAMESPACE_BEGIN ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view str, int_type *out)
Definition: abseil-cpp/absl/strings/numbers.h:271
in
const char * in
Definition: third_party/abseil-cpp/absl/strings/internal/str_format/parser_test.cc:391
autogen_x86imm.f
f
Definition: autogen_x86imm.py:9
int16_t
signed short int16_t
Definition: stdint-msvc2008.h:76
int64_t
signed __int64 int64_t
Definition: stdint-msvc2008.h:89
AbslUnparseFlag
std::string AbslUnparseFlag(const UDT &)
Definition: bloaty/third_party/abseil-cpp/absl/flags/internal/usage_test.cc:50
EXPECT_NE
#define EXPECT_NE(val1, val2)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2028
uint64_t
unsigned __int64 uint64_t
Definition: stdint-msvc2008.h:90
counter
static int counter
Definition: abseil-cpp/absl/flags/reflection_test.cc:131
absl::Duration
Definition: third_party/abseil-cpp/absl/time/time.h:159
absl::GetFlag
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag< T > &flag)
Definition: abseil-cpp/absl/flags/flag.h:98
a_
arena< N > & a_
Definition: cxa_demangle.cpp:4778
b
uint64_t b
Definition: abseil-cpp/absl/container/internal/layout_test.cc:53
testing::Test::SetUp
virtual void SetUp()
Definition: bloaty/third_party/googletest/googletest/src/gtest.cc:2264
ABSL_RETIRED_FLAG
ABSL_RETIRED_FLAG(bool, bool_retired_flag, false, "bool_retired_flag help")
absl::FlagSaver
Definition: abseil-cpp/absl/flags/reflection.h:73
absl::SkipWhitespace
Definition: abseil-cpp/absl/strings/str_split.h:365
absl::Hours
constexpr Duration Hours(T n)
Definition: third_party/abseil-cpp/absl/time/time.h:427
AbslParseFlag
bool AbslParseFlag(absl::string_view, UDT *, std::string *)
Definition: bloaty/third_party/abseil-cpp/absl/flags/internal/usage_test.cc:49
ABSL_FLAG
ABSL_FLAG(int, int_flag, 1, "int_flag help")
absl::Minutes
constexpr Duration Minutes(T n)
Definition: third_party/abseil-cpp/absl/time/time.h:423
EXPECT_TRUE
#define EXPECT_TRUE(condition)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:1967
EXPECT_NEAR
#define EXPECT_NEAR(val1, val2, abs_error)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2143
b_
const char * b_
Definition: bloaty/third_party/protobuf/src/google/protobuf/stubs/common_unittest.cc:194
handle
static csh handle
Definition: test_arm_regression.c:16
testing::UnorderedElementsAreArray
internal::UnorderedElementsAreArrayMatcher< typename ::std::iterator_traits< Iter >::value_type > UnorderedElementsAreArray(Iter first, Iter last)
Definition: cares/cares/test/gmock-1.8.0/gmock/gmock.h:8507
xds_manager.f2
f2
Definition: xds_manager.py:85
int32_t
signed int int32_t
Definition: stdint-msvc2008.h:77
absl::GetAllFlags
absl::flat_hash_map< absl::string_view, absl::CommandLineFlag * > GetAllFlags()
Definition: abseil-cpp/absl/flags/reflection.cc:345
TEST_F
#define TEST_F(test_fixture, test_name)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:2367

grpc
Author(s):
autogenerated on Fri May 16 2025 03:00:01