bloaty/third_party/abseil-cpp/absl/flags/flag_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/flag.h"
17 
18 #include <stddef.h>
19 #include <stdint.h>
20 
21 #include <atomic>
22 #include <cmath>
23 #include <new>
24 #include <string>
25 #include <thread> // NOLINT
26 #include <vector>
27 
28 #include "gtest/gtest.h"
29 #include "absl/base/attributes.h"
30 #include "absl/base/macros.h"
31 #include "absl/flags/config.h"
32 #include "absl/flags/declare.h"
33 #include "absl/flags/internal/flag.h"
34 #include "absl/flags/marshalling.h"
35 #include "absl/flags/reflection.h"
36 #include "absl/flags/usage_config.h"
37 #include "absl/strings/match.h"
38 #include "absl/strings/numbers.h"
39 #include "absl/strings/str_cat.h"
40 #include "absl/strings/str_split.h"
41 #include "absl/strings/string_view.h"
42 #include "absl/time/time.h"
43 
44 ABSL_DECLARE_FLAG(int64_t, mistyped_int_flag);
45 ABSL_DECLARE_FLAG(std::vector<std::string>, mistyped_string_flag);
46 
47 namespace {
48 
49 namespace flags = absl::flags_internal;
50 
51 std::string TestHelpMsg() { return "dynamic help"; }
52 #if defined(_MSC_VER) && !defined(__clang__)
53 std::string TestLiteralHelpMsg() { return "literal help"; }
54 #endif
55 template <typename T>
56 void TestMakeDflt(void* dst) {
57  new (dst) T{};
58 }
59 void TestCallback() {}
60 
61 struct UDT {
62  UDT() = default;
63  UDT(const UDT&) = default;
64 };
65 bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
66 std::string AbslUnparseFlag(const UDT&) { return ""; }
67 
68 class FlagTest : public testing::Test {
69  protected:
70  static void SetUpTestSuite() {
71  // Install a function to normalize filenames before this test is run.
72  absl::FlagsUsageConfig default_config;
73  default_config.normalize_filename = &FlagTest::NormalizeFileName;
74  absl::SetFlagsUsageConfig(default_config);
75  }
76 
77  private:
78  static std::string NormalizeFileName(absl::string_view fname) {
79 #ifdef _WIN32
80  std::string normalized(fname);
81  std::replace(normalized.begin(), normalized.end(), '\\', '/');
82  fname = normalized;
83 #endif
84  return std::string(fname);
85  }
86  absl::FlagSaver flag_saver_;
87 };
88 
89 struct S1 {
90  S1() = default;
91  S1(const S1&) = default;
92  int32_t f1;
93  int64_t f2;
94 };
95 
96 struct S2 {
97  S2() = default;
98  S2(const S2&) = default;
99  int64_t f1;
100  double f2;
101 };
102 
103 TEST_F(FlagTest, Traits) {
104  EXPECT_EQ(flags::StorageKind<int>(),
105  flags::FlagValueStorageKind::kOneWordAtomic);
106  EXPECT_EQ(flags::StorageKind<bool>(),
107  flags::FlagValueStorageKind::kOneWordAtomic);
108  EXPECT_EQ(flags::StorageKind<double>(),
109  flags::FlagValueStorageKind::kOneWordAtomic);
110  EXPECT_EQ(flags::StorageKind<int64_t>(),
111  flags::FlagValueStorageKind::kOneWordAtomic);
112 
113  EXPECT_EQ(flags::StorageKind<S1>(),
114  flags::FlagValueStorageKind::kSequenceLocked);
115  EXPECT_EQ(flags::StorageKind<S2>(),
116  flags::FlagValueStorageKind::kSequenceLocked);
117 // Make sure absl::Duration uses the sequence-locked code path. MSVC 2015
118 // doesn't consider absl::Duration to be trivially-copyable so we just
119 // restrict this to clang as it seems to be a well-behaved compiler.
120 #ifdef __clang__
121  EXPECT_EQ(flags::StorageKind<absl::Duration>(),
122  flags::FlagValueStorageKind::kSequenceLocked);
123 #endif
124 
125  EXPECT_EQ(flags::StorageKind<std::string>(),
126  flags::FlagValueStorageKind::kAlignedBuffer);
127  EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
128  flags::FlagValueStorageKind::kAlignedBuffer);
129 }
130 
131 // --------------------------------------------------------------------
132 
133 constexpr flags::FlagHelpArg help_arg{flags::FlagHelpMsg("literal help"),
134  flags::FlagHelpKind::kLiteral};
135 
136 using String = std::string;
137 
138 #if !defined(_MSC_VER) || defined(__clang__)
139 #define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind) \
140  constexpr flags::FlagDefaultArg f1default##T{ \
141  flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind}; \
142  constexpr absl::Flag<T> f1##T{"f1", "file", help_arg, f1default##T}; \
143  ABSL_CONST_INIT absl::Flag<T> f2##T { \
144  "f2", "file", \
145  {flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, \
146  flags::FlagDefaultArg { \
147  flags::FlagDefaultSrc(&TestMakeDflt<T>), \
148  flags::FlagDefaultKind::kGenFunc \
149  } \
150  }
151 #else
152 #define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind) \
153  constexpr flags::FlagDefaultArg f1default##T{ \
154  flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind}; \
155  constexpr absl::Flag<T> f1##T{"f1", "file", &TestLiteralHelpMsg, \
156  &TestMakeDflt<T>}; \
157  ABSL_CONST_INIT absl::Flag<T> f2##T { \
158  "f2", "file", &TestHelpMsg, &TestMakeDflt<T> \
159  }
160 #endif
161 
162 DEFINE_CONSTRUCTED_FLAG(bool, true, kOneWord);
163 DEFINE_CONSTRUCTED_FLAG(int16_t, 1, kOneWord);
164 DEFINE_CONSTRUCTED_FLAG(uint16_t, 2, kOneWord);
165 DEFINE_CONSTRUCTED_FLAG(int32_t, 3, kOneWord);
166 DEFINE_CONSTRUCTED_FLAG(uint32_t, 4, kOneWord);
167 DEFINE_CONSTRUCTED_FLAG(int64_t, 5, kOneWord);
168 DEFINE_CONSTRUCTED_FLAG(uint64_t, 6, kOneWord);
169 DEFINE_CONSTRUCTED_FLAG(float, 7.8, kOneWord);
170 DEFINE_CONSTRUCTED_FLAG(double, 9.10, kOneWord);
171 DEFINE_CONSTRUCTED_FLAG(String, &TestMakeDflt<String>, kGenFunc);
172 DEFINE_CONSTRUCTED_FLAG(UDT, &TestMakeDflt<UDT>, kGenFunc);
173 
174 template <typename T>
175 bool TestConstructionFor(const absl::Flag<T>& f1, absl::Flag<T>& f2) {
176  EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Name(), "f1");
177  EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Help(), "literal help");
178  EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Filename(), "file");
179 
180  flags::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(f2), nullptr)
181  .OnUpdate(TestCallback);
182 
183  EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Name(), "f2");
184  EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Help(), "dynamic help");
185  EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Filename(), "file");
186 
187  return true;
188 }
189 
190 #define TEST_CONSTRUCTED_FLAG(T) TestConstructionFor(f1##T, f2##T);
191 
192 TEST_F(FlagTest, TestConstruction) {
193  TEST_CONSTRUCTED_FLAG(bool);
194  TEST_CONSTRUCTED_FLAG(int16_t);
195  TEST_CONSTRUCTED_FLAG(uint16_t);
196  TEST_CONSTRUCTED_FLAG(int32_t);
197  TEST_CONSTRUCTED_FLAG(uint32_t);
198  TEST_CONSTRUCTED_FLAG(int64_t);
199  TEST_CONSTRUCTED_FLAG(uint64_t);
200  TEST_CONSTRUCTED_FLAG(float);
201  TEST_CONSTRUCTED_FLAG(double);
202  TEST_CONSTRUCTED_FLAG(String);
203  TEST_CONSTRUCTED_FLAG(UDT);
204 }
205 
206 // --------------------------------------------------------------------
207 
208 } // namespace
209 
210 ABSL_DECLARE_FLAG(bool, test_flag_01);
211 ABSL_DECLARE_FLAG(int, test_flag_02);
212 ABSL_DECLARE_FLAG(int16_t, test_flag_03);
213 ABSL_DECLARE_FLAG(uint16_t, test_flag_04);
214 ABSL_DECLARE_FLAG(int32_t, test_flag_05);
215 ABSL_DECLARE_FLAG(uint32_t, test_flag_06);
216 ABSL_DECLARE_FLAG(int64_t, test_flag_07);
217 ABSL_DECLARE_FLAG(uint64_t, test_flag_08);
218 ABSL_DECLARE_FLAG(double, test_flag_09);
219 ABSL_DECLARE_FLAG(float, test_flag_10);
220 ABSL_DECLARE_FLAG(std::string, test_flag_11);
221 ABSL_DECLARE_FLAG(absl::Duration, test_flag_12);
222 
223 namespace {
224 
225 #if !ABSL_FLAGS_STRIP_NAMES
226 
227 TEST_F(FlagTest, TestFlagDeclaration) {
228  // test that we can access flag objects.
229  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
230  "test_flag_01");
231  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
232  "test_flag_02");
233  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
234  "test_flag_03");
235  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
236  "test_flag_04");
237  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
238  "test_flag_05");
239  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
240  "test_flag_06");
241  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
242  "test_flag_07");
243  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
244  "test_flag_08");
245  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
246  "test_flag_09");
247  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
248  "test_flag_10");
249  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
250  "test_flag_11");
251  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
252  "test_flag_12");
253 }
254 #endif // !ABSL_FLAGS_STRIP_NAMES
255 
256 // --------------------------------------------------------------------
257 
258 } // namespace
259 
260 ABSL_FLAG(bool, test_flag_01, true, "test flag 01");
261 ABSL_FLAG(int, test_flag_02, 1234, "test flag 02");
262 ABSL_FLAG(int16_t, test_flag_03, -34, "test flag 03");
263 ABSL_FLAG(uint16_t, test_flag_04, 189, "test flag 04");
264 ABSL_FLAG(int32_t, test_flag_05, 10765, "test flag 05");
265 ABSL_FLAG(uint32_t, test_flag_06, 40000, "test flag 06");
266 ABSL_FLAG(int64_t, test_flag_07, -1234567, "test flag 07");
267 ABSL_FLAG(uint64_t, test_flag_08, 9876543, "test flag 08");
268 ABSL_FLAG(double, test_flag_09, -9.876e-50, "test flag 09");
269 ABSL_FLAG(float, test_flag_10, 1.234e12f, "test flag 10");
270 ABSL_FLAG(std::string, test_flag_11, "", "test flag 11");
271 ABSL_FLAG(absl::Duration, test_flag_12, absl::Minutes(10), "test flag 12");
272 
273 namespace {
274 
275 #if !ABSL_FLAGS_STRIP_NAMES
276 TEST_F(FlagTest, TestFlagDefinition) {
277  absl::string_view expected_file_name = "absl/flags/flag_test.cc";
278 
279  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
280  "test_flag_01");
281  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Help(),
282  "test flag 01");
283  EXPECT_TRUE(absl::EndsWith(
284  absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename(),
285  expected_file_name))
286  << absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename();
287 
288  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
289  "test_flag_02");
290  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Help(),
291  "test flag 02");
292  EXPECT_TRUE(absl::EndsWith(
293  absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename(),
294  expected_file_name))
295  << absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename();
296 
297  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
298  "test_flag_03");
299  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Help(),
300  "test flag 03");
301  EXPECT_TRUE(absl::EndsWith(
302  absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename(),
303  expected_file_name))
304  << absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename();
305 
306  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
307  "test_flag_04");
308  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Help(),
309  "test flag 04");
310  EXPECT_TRUE(absl::EndsWith(
311  absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename(),
312  expected_file_name))
313  << absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename();
314 
315  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
316  "test_flag_05");
317  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Help(),
318  "test flag 05");
319  EXPECT_TRUE(absl::EndsWith(
320  absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename(),
321  expected_file_name))
322  << absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename();
323 
324  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
325  "test_flag_06");
326  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Help(),
327  "test flag 06");
328  EXPECT_TRUE(absl::EndsWith(
329  absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename(),
330  expected_file_name))
331  << absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename();
332 
333  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
334  "test_flag_07");
335  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Help(),
336  "test flag 07");
337  EXPECT_TRUE(absl::EndsWith(
338  absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename(),
339  expected_file_name))
340  << absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename();
341 
342  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
343  "test_flag_08");
344  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Help(),
345  "test flag 08");
346  EXPECT_TRUE(absl::EndsWith(
347  absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename(),
348  expected_file_name))
349  << absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename();
350 
351  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
352  "test_flag_09");
353  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Help(),
354  "test flag 09");
355  EXPECT_TRUE(absl::EndsWith(
356  absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename(),
357  expected_file_name))
358  << absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename();
359 
360  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
361  "test_flag_10");
362  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Help(),
363  "test flag 10");
364  EXPECT_TRUE(absl::EndsWith(
365  absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename(),
366  expected_file_name))
367  << absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename();
368 
369  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
370  "test_flag_11");
371  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Help(),
372  "test flag 11");
373  EXPECT_TRUE(absl::EndsWith(
374  absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename(),
375  expected_file_name))
376  << absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename();
377 
378  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
379  "test_flag_12");
380  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Help(),
381  "test flag 12");
382  EXPECT_TRUE(absl::EndsWith(
383  absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename(),
384  expected_file_name))
385  << absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename();
386 }
387 #endif // !ABSL_FLAGS_STRIP_NAMES
388 
389 // --------------------------------------------------------------------
390 
391 TEST_F(FlagTest, TestDefault) {
392  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).DefaultValue(),
393  "true");
394  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).DefaultValue(),
395  "1234");
396  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).DefaultValue(),
397  "-34");
398  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).DefaultValue(),
399  "189");
400  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).DefaultValue(),
401  "10765");
402  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).DefaultValue(),
403  "40000");
404  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).DefaultValue(),
405  "-1234567");
406  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).DefaultValue(),
407  "9876543");
408  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).DefaultValue(),
409  "-9.876e-50");
410  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).DefaultValue(),
411  "1.234e+12");
412  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).DefaultValue(),
413  "");
414  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).DefaultValue(),
415  "10m");
416 
417  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).CurrentValue(),
418  "true");
419  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).CurrentValue(),
420  "1234");
421  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).CurrentValue(),
422  "-34");
423  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).CurrentValue(),
424  "189");
425  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).CurrentValue(),
426  "10765");
427  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).CurrentValue(),
428  "40000");
429  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).CurrentValue(),
430  "-1234567");
431  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).CurrentValue(),
432  "9876543");
433  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).CurrentValue(),
434  "-9.876e-50");
435  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).CurrentValue(),
436  "1.234e+12");
437  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).CurrentValue(),
438  "");
439  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).CurrentValue(),
440  "10m");
441 
442  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true);
443  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234);
444  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34);
445  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189);
446  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765);
447  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000);
448  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567);
449  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
450  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55);
451  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f);
452  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "");
453  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10));
454 }
455 
456 // --------------------------------------------------------------------
457 
458 struct NonTriviallyCopyableAggregate {
459  NonTriviallyCopyableAggregate() = default;
460  NonTriviallyCopyableAggregate(const NonTriviallyCopyableAggregate& rhs)
461  : value(rhs.value) {}
462  NonTriviallyCopyableAggregate& operator=(
463  const NonTriviallyCopyableAggregate& rhs) {
464  value = rhs.value;
465  return *this;
466  }
467 
468  int value;
469 };
470 bool AbslParseFlag(absl::string_view src, NonTriviallyCopyableAggregate* f,
471  std::string* e) {
472  return absl::ParseFlag(src, &f->value, e);
473 }
474 std::string AbslUnparseFlag(const NonTriviallyCopyableAggregate& ntc) {
475  return absl::StrCat(ntc.value);
476 }
477 
478 bool operator==(const NonTriviallyCopyableAggregate& ntc1,
479  const NonTriviallyCopyableAggregate& ntc2) {
480  return ntc1.value == ntc2.value;
481 }
482 
483 } // namespace
484 
485 ABSL_FLAG(bool, test_flag_eb_01, {}, "");
486 ABSL_FLAG(int32_t, test_flag_eb_02, {}, "");
487 ABSL_FLAG(int64_t, test_flag_eb_03, {}, "");
488 ABSL_FLAG(double, test_flag_eb_04, {}, "");
489 ABSL_FLAG(std::string, test_flag_eb_05, {}, "");
490 ABSL_FLAG(NonTriviallyCopyableAggregate, test_flag_eb_06, {}, "");
491 
492 namespace {
493 
494 TEST_F(FlagTest, TestEmptyBracesDefault) {
495  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_01).DefaultValue(),
496  "false");
497  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_02).DefaultValue(),
498  "0");
499  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_03).DefaultValue(),
500  "0");
501  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_04).DefaultValue(),
502  "0");
503  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_05).DefaultValue(),
504  "");
505  EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_06).DefaultValue(),
506  "0");
507 
508  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_01), false);
509  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_02), 0);
510  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_03), 0);
511  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_04), 0.0);
512  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_05), "");
513  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_06),
514  NonTriviallyCopyableAggregate{});
515 }
516 
517 // --------------------------------------------------------------------
518 
519 TEST_F(FlagTest, TestGetSet) {
520  absl::SetFlag(&FLAGS_test_flag_01, false);
521  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), false);
522 
523  absl::SetFlag(&FLAGS_test_flag_02, 321);
524  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 321);
525 
526  absl::SetFlag(&FLAGS_test_flag_03, 67);
527  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), 67);
528 
529  absl::SetFlag(&FLAGS_test_flag_04, 1);
530  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 1);
531 
532  absl::SetFlag(&FLAGS_test_flag_05, -908);
533  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), -908);
534 
535  absl::SetFlag(&FLAGS_test_flag_06, 4001);
536  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 4001);
537 
538  absl::SetFlag(&FLAGS_test_flag_07, -23456);
539  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -23456);
540 
541  absl::SetFlag(&FLAGS_test_flag_08, 975310);
542  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 975310);
543 
544  absl::SetFlag(&FLAGS_test_flag_09, 1.00001);
545  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), 1.00001, 1e-10);
546 
547  absl::SetFlag(&FLAGS_test_flag_10, -3.54f);
548  EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), -3.54f, 1e-6f);
549 
550  absl::SetFlag(&FLAGS_test_flag_11, "asdf");
551  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "asdf");
552 
553  absl::SetFlag(&FLAGS_test_flag_12, absl::Seconds(110));
554  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Seconds(110));
555 }
556 
557 // --------------------------------------------------------------------
558 
559 TEST_F(FlagTest, TestGetViaReflection) {
560  auto* handle = absl::FindCommandLineFlag("test_flag_01");
561  EXPECT_EQ(*handle->TryGet<bool>(), true);
562  handle = absl::FindCommandLineFlag("test_flag_02");
563  EXPECT_EQ(*handle->TryGet<int>(), 1234);
564  handle = absl::FindCommandLineFlag("test_flag_03");
565  EXPECT_EQ(*handle->TryGet<int16_t>(), -34);
566  handle = absl::FindCommandLineFlag("test_flag_04");
567  EXPECT_EQ(*handle->TryGet<uint16_t>(), 189);
568  handle = absl::FindCommandLineFlag("test_flag_05");
569  EXPECT_EQ(*handle->TryGet<int32_t>(), 10765);
570  handle = absl::FindCommandLineFlag("test_flag_06");
571  EXPECT_EQ(*handle->TryGet<uint32_t>(), 40000);
572  handle = absl::FindCommandLineFlag("test_flag_07");
573  EXPECT_EQ(*handle->TryGet<int64_t>(), -1234567);
574  handle = absl::FindCommandLineFlag("test_flag_08");
575  EXPECT_EQ(*handle->TryGet<uint64_t>(), 9876543);
576  handle = absl::FindCommandLineFlag("test_flag_09");
577  EXPECT_NEAR(*handle->TryGet<double>(), -9.876e-50, 1e-55);
578  handle = absl::FindCommandLineFlag("test_flag_10");
579  EXPECT_NEAR(*handle->TryGet<float>(), 1.234e12f, 1e5f);
580  handle = absl::FindCommandLineFlag("test_flag_11");
581  EXPECT_EQ(*handle->TryGet<std::string>(), "");
582  handle = absl::FindCommandLineFlag("test_flag_12");
583  EXPECT_EQ(*handle->TryGet<absl::Duration>(), absl::Minutes(10));
584 }
585 
586 // --------------------------------------------------------------------
587 
588 TEST_F(FlagTest, ConcurrentSetAndGet) {
589  static constexpr int kNumThreads = 8;
590  // Two arbitrary durations. One thread will concurrently flip the flag
591  // between these two values, while the other threads read it and verify
592  // that no other value is seen.
593  static const absl::Duration kValidDurations[] = {
594  absl::Seconds(int64_t{0x6cebf47a9b68c802}) + absl::Nanoseconds(229702057),
595  absl::Seconds(int64_t{0x23fec0307e4e9d3}) + absl::Nanoseconds(44555374)};
596  absl::SetFlag(&FLAGS_test_flag_12, kValidDurations[0]);
597 
598  std::atomic<bool> stop{false};
599  std::vector<std::thread> threads;
600  auto* handle = absl::FindCommandLineFlag("test_flag_12");
601  for (int i = 0; i < kNumThreads; i++) {
602  threads.emplace_back([&]() {
603  while (!stop.load(std::memory_order_relaxed)) {
604  // Try loading the flag both directly and via a reflection
605  // handle.
606  absl::Duration v = absl::GetFlag(FLAGS_test_flag_12);
607  EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
608  v = *handle->TryGet<absl::Duration>();
609  EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
610  }
611  });
612  }
613  absl::Time end_time = absl::Now() + absl::Seconds(1);
614  int i = 0;
615  while (absl::Now() < end_time) {
616  absl::SetFlag(&FLAGS_test_flag_12,
617  kValidDurations[i++ % ABSL_ARRAYSIZE(kValidDurations)]);
618  }
619  stop.store(true, std::memory_order_relaxed);
620  for (auto& t : threads) t.join();
621 }
622 
623 // --------------------------------------------------------------------
624 
625 int GetDflt1() { return 1; }
626 
627 } // namespace
628 
629 ABSL_FLAG(int, test_int_flag_with_non_const_default, GetDflt1(),
630  "test int flag non const default");
631 ABSL_FLAG(std::string, test_string_flag_with_non_const_default,
632  absl::StrCat("AAA", "BBB"), "test string flag non const default");
633 
634 namespace {
635 
636 TEST_F(FlagTest, TestNonConstexprDefault) {
637  EXPECT_EQ(absl::GetFlag(FLAGS_test_int_flag_with_non_const_default), 1);
638  EXPECT_EQ(absl::GetFlag(FLAGS_test_string_flag_with_non_const_default),
639  "AAABBB");
640 }
641 
642 // --------------------------------------------------------------------
643 
644 } // namespace
645 
646 ABSL_FLAG(bool, test_flag_with_non_const_help, true,
647  absl::StrCat("test ", "flag ", "non const help"));
648 
649 namespace {
650 
651 #if !ABSL_FLAGS_STRIP_HELP
652 TEST_F(FlagTest, TestNonConstexprHelp) {
653  EXPECT_EQ(
654  absl::GetFlagReflectionHandle(FLAGS_test_flag_with_non_const_help).Help(),
655  "test flag non const help");
656 }
657 #endif
658 
659 // --------------------------------------------------------------------
660 
661 int cb_test_value = -1;
662 void TestFlagCB();
663 
664 } // namespace
665 
666 ABSL_FLAG(int, test_flag_with_cb, 100, "").OnUpdate(TestFlagCB);
667 
668 ABSL_FLAG(int, test_flag_with_lambda_cb, 200, "").OnUpdate([]() {
669  cb_test_value = absl::GetFlag(FLAGS_test_flag_with_lambda_cb) +
670  absl::GetFlag(FLAGS_test_flag_with_cb);
671 });
672 
673 namespace {
674 
675 void TestFlagCB() { cb_test_value = absl::GetFlag(FLAGS_test_flag_with_cb); }
676 
677 // Tests side-effects of callback invocation.
678 TEST_F(FlagTest, CallbackInvocation) {
679  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_cb), 100);
680  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_lambda_cb), 200);
681  EXPECT_EQ(cb_test_value, 300);
682 
683  absl::SetFlag(&FLAGS_test_flag_with_cb, 1);
684  EXPECT_EQ(cb_test_value, 1);
685 
686  absl::SetFlag(&FLAGS_test_flag_with_lambda_cb, 3);
687  EXPECT_EQ(cb_test_value, 4);
688 }
689 
690 // --------------------------------------------------------------------
691 
692 struct CustomUDT {
693  CustomUDT() : a(1), b(1) {}
694  CustomUDT(int a_, int b_) : a(a_), b(b_) {}
695 
696  friend bool operator==(const CustomUDT& f1, const CustomUDT& f2) {
697  return f1.a == f2.a && f1.b == f2.b;
698  }
699 
700  int a;
701  int b;
702 };
703 bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) {
704  std::vector<absl::string_view> parts =
705  absl::StrSplit(in, ':', absl::SkipWhitespace());
706 
707  if (parts.size() != 2) return false;
708 
709  if (!absl::SimpleAtoi(parts[0], &f->a)) return false;
710 
711  if (!absl::SimpleAtoi(parts[1], &f->b)) return false;
712 
713  return true;
714 }
715 std::string AbslUnparseFlag(const CustomUDT& f) {
716  return absl::StrCat(f.a, ":", f.b);
717 }
718 
719 } // namespace
720 
721 ABSL_FLAG(CustomUDT, test_flag_custom_udt, CustomUDT(), "test flag custom UDT");
722 
723 namespace {
724 
725 TEST_F(FlagTest, TestCustomUDT) {
726  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(1, 1));
727  absl::SetFlag(&FLAGS_test_flag_custom_udt, CustomUDT(2, 3));
728  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(2, 3));
729 }
730 
731 // MSVC produces link error on the type mismatch.
732 // Linux does not have build errors and validations work as expected.
733 #if !defined(_WIN32) && GTEST_HAS_DEATH_TEST
734 
735 using FlagDeathTest = FlagTest;
736 
737 TEST_F(FlagDeathTest, TestTypeMismatchValidations) {
738 #if !defined(NDEBUG)
739  EXPECT_DEATH_IF_SUPPORTED(
740  static_cast<void>(absl::GetFlag(FLAGS_mistyped_int_flag)),
741  "Flag 'mistyped_int_flag' is defined as one type and declared "
742  "as another");
743  EXPECT_DEATH_IF_SUPPORTED(
744  static_cast<void>(absl::GetFlag(FLAGS_mistyped_string_flag)),
745  "Flag 'mistyped_string_flag' is defined as one type and "
746  "declared as another");
747 #endif
748 
749  EXPECT_DEATH_IF_SUPPORTED(
750  absl::SetFlag(&FLAGS_mistyped_int_flag, 1),
751  "Flag 'mistyped_int_flag' is defined as one type and declared "
752  "as another");
753  EXPECT_DEATH_IF_SUPPORTED(
754  absl::SetFlag(&FLAGS_mistyped_string_flag, std::vector<std::string>{}),
755  "Flag 'mistyped_string_flag' is defined as one type and declared as "
756  "another");
757 }
758 
759 #endif
760 
761 // --------------------------------------------------------------------
762 
763 // A contrived type that offers implicit and explicit conversion from specific
764 // source types.
765 struct ConversionTestVal {
766  ConversionTestVal() = default;
767  explicit ConversionTestVal(int a_in) : a(a_in) {}
768 
769  enum class ViaImplicitConv { kTen = 10, kEleven };
770  // NOLINTNEXTLINE
771  ConversionTestVal(ViaImplicitConv from) : a(static_cast<int>(from)) {}
772 
773  int a;
774 };
775 
776 bool AbslParseFlag(absl::string_view in, ConversionTestVal* val_out,
777  std::string*) {
778  if (!absl::SimpleAtoi(in, &val_out->a)) {
779  return false;
780  }
781  return true;
782 }
783 std::string AbslUnparseFlag(const ConversionTestVal& val) {
784  return absl::StrCat(val.a);
785 }
786 
787 } // namespace
788 
789 // Flag default values can be specified with a value that converts to the flag
790 // value type implicitly.
791 ABSL_FLAG(ConversionTestVal, test_flag_implicit_conv,
792  ConversionTestVal::ViaImplicitConv::kTen,
793  "test flag init via implicit conversion");
794 
795 namespace {
796 
797 TEST_F(FlagTest, CanSetViaImplicitConversion) {
798  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 10);
799  absl::SetFlag(&FLAGS_test_flag_implicit_conv,
800  ConversionTestVal::ViaImplicitConv::kEleven);
801  EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 11);
802 }
803 
804 // --------------------------------------------------------------------
805 
806 struct NonDfltConstructible {
807  public:
808  // This constructor tests that we can initialize the flag with int value
809  NonDfltConstructible(int i) : value(i) {} // NOLINT
810 
811  // This constructor tests that we can't initialize the flag with char value
812  // but can with explicitly constructed NonDfltConstructible.
813  explicit NonDfltConstructible(char c) : value(100 + static_cast<int>(c)) {}
814 
815  int value;
816 };
817 
818 bool AbslParseFlag(absl::string_view in, NonDfltConstructible* ndc_out,
819  std::string*) {
820  return absl::SimpleAtoi(in, &ndc_out->value);
821 }
822 std::string AbslUnparseFlag(const NonDfltConstructible& ndc) {
823  return absl::StrCat(ndc.value);
824 }
825 
826 } // namespace
827 
828 ABSL_FLAG(NonDfltConstructible, ndc_flag1, NonDfltConstructible('1'),
829  "Flag with non default constructible type");
830 ABSL_FLAG(NonDfltConstructible, ndc_flag2, 0,
831  "Flag with non default constructible type");
832 
833 namespace {
834 
835 TEST_F(FlagTest, TestNonDefaultConstructibleType) {
836  EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, '1' + 100);
837  EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 0);
838 
839  absl::SetFlag(&FLAGS_ndc_flag1, NonDfltConstructible('A'));
840  absl::SetFlag(&FLAGS_ndc_flag2, 25);
841 
842  EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, 'A' + 100);
843  EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 25);
844 }
845 
846 } // namespace
847 
848 // --------------------------------------------------------------------
849 
850 ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr");
851 ABSL_RETIRED_FLAG(int, old_int_flag, (int)std::sqrt(10), "old descr");
852 ABSL_RETIRED_FLAG(std::string, old_str_flag, "", absl::StrCat("old ", "descr"));
853 
854 bool initializaion_order_fiasco_test = [] {
855  // Iterate over all the flags during static initialization.
856  // This should not trigger ASan's initialization-order-fiasco.
857  auto* handle1 = absl::FindCommandLineFlag("flag_on_separate_file");
858  auto* handle2 = absl::FindCommandLineFlag("retired_flag_on_separate_file");
859  if (handle1 != nullptr && handle2 != nullptr) {
860  return handle1->Name() == handle2->Name();
861  }
862  return true;
863 }();
864 
865 namespace {
866 
867 TEST_F(FlagTest, TestRetiredFlagRegistration) {
868  auto* handle = absl::FindCommandLineFlag("old_bool_flag");
869  EXPECT_TRUE(handle->IsOfType<bool>());
870  EXPECT_TRUE(handle->IsRetired());
871  handle = absl::FindCommandLineFlag("old_int_flag");
872  EXPECT_TRUE(handle->IsOfType<int>());
873  EXPECT_TRUE(handle->IsRetired());
874  handle = absl::FindCommandLineFlag("old_str_flag");
875  EXPECT_TRUE(handle->IsOfType<std::string>());
876  EXPECT_TRUE(handle->IsRetired());
877 }
878 
879 } // namespace
880 
881 // --------------------------------------------------------------------
882 
883 namespace {
884 
885 // User-defined type with small alignment, but size exceeding 16.
886 struct SmallAlignUDT {
887  SmallAlignUDT() : c('A'), s(12) {}
888  char c;
889  int16_t s;
890  char bytes[14];
891 };
892 
893 bool AbslParseFlag(absl::string_view, SmallAlignUDT*, std::string*) {
894  return true;
895 }
896 std::string AbslUnparseFlag(const SmallAlignUDT&) { return ""; }
897 
898 // User-defined type with small size, but not trivially copyable.
899 struct NonTriviallyCopyableUDT {
900  NonTriviallyCopyableUDT() : c('A') {}
901  NonTriviallyCopyableUDT(const NonTriviallyCopyableUDT& rhs) : c(rhs.c) {}
902  NonTriviallyCopyableUDT& operator=(const NonTriviallyCopyableUDT& rhs) {
903  c = rhs.c;
904  return *this;
905  }
906 
907  char c;
908 };
909 
910 bool AbslParseFlag(absl::string_view, NonTriviallyCopyableUDT*, std::string*) {
911  return true;
912 }
913 std::string AbslUnparseFlag(const NonTriviallyCopyableUDT&) { return ""; }
914 
915 } // namespace
916 
917 ABSL_FLAG(SmallAlignUDT, test_flag_sa_udt, {}, "help");
918 ABSL_FLAG(NonTriviallyCopyableUDT, test_flag_ntc_udt, {}, "help");
919 
920 namespace {
921 
922 TEST_F(FlagTest, TestSmallAlignUDT) {
923  SmallAlignUDT value = absl::GetFlag(FLAGS_test_flag_sa_udt);
924  EXPECT_EQ(value.c, 'A');
925  EXPECT_EQ(value.s, 12);
926 
927  value.c = 'B';
928  value.s = 45;
929  absl::SetFlag(&FLAGS_test_flag_sa_udt, value);
930  value = absl::GetFlag(FLAGS_test_flag_sa_udt);
931  EXPECT_EQ(value.c, 'B');
932  EXPECT_EQ(value.s, 45);
933 }
934 
935 TEST_F(FlagTest, TestNonTriviallyCopyableUDT) {
936  NonTriviallyCopyableUDT value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
937  EXPECT_EQ(value.c, 'A');
938 
939  value.c = 'B';
940  absl::SetFlag(&FLAGS_test_flag_ntc_udt, value);
941  value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
942  EXPECT_EQ(value.c, 'B');
943 }
944 
945 } // 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::GetFlagReflectionHandle
const CommandLineFlag & GetFlagReflectionHandle(const absl::Flag< T > &f)
Definition: abseil-cpp/absl/flags/flag.h:134
dst
static const char dst[]
Definition: test-fs-copyfile.c:37
absl::SetFlag
void SetFlag(absl::Flag< T > *flag, const T &v)
Definition: abseil-cpp/absl/flags/flag.h:110
absl::ParseFlag
ABSL_NAMESPACE_BEGIN bool ParseFlag(absl::string_view input, T *dst, std::string *error)
Definition: abseil-cpp/absl/flags/marshalling.h:328
Filename
static std::string Filename(const protobuf::FileDescriptor *file)
Definition: upbc.cc:53
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
absl::Time
Definition: third_party/abseil-cpp/absl/time/time.h:642
uint16_t
unsigned short uint16_t
Definition: stdint-msvc2008.h:79
xds_manager.f1
f1
Definition: xds_manager.py:42
absl::Nanoseconds
constexpr Duration Nanoseconds(T n)
Definition: third_party/abseil-cpp/absl/time/time.h:407
absl::string_view
Definition: abseil-cpp/absl/strings/string_view.h:167
testing::Test::SetUpTestSuite
static void SetUpTestSuite()
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest.h:417
absl::flags_internal::FlagHelpArg
Definition: abseil-cpp/absl/flags/internal/flag.h:213
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
end_time
static int64_t end_time
Definition: benchmark-getaddrinfo.c:38
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
absl::FlagsUsageConfig::normalize_filename
std::function< std::string(absl::string_view)> normalize_filename
Definition: abseil-cpp/absl/flags/usage_config.h:106
ABSL_ARRAYSIZE
#define ABSL_ARRAYSIZE(array)
Definition: abseil-cpp/absl/base/macros.h:44
T
#define T(upbtypeconst, upbtype, ctype, default_value)
threads
static uv_thread_t * threads
Definition: threadpool.c:38
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
uint32_t
unsigned int uint32_t
Definition: stdint-msvc2008.h:80
from
size_t from
Definition: abseil-cpp/absl/container/internal/layout_test.cc:1384
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
c
void c(T a)
Definition: miscompile_with_no_unique_address_test.cc:40
autogen_x86imm.f
f
Definition: autogen_x86imm.py:9
int16_t
signed short int16_t
Definition: stdint-msvc2008.h:76
xds_interop_client.int
int
Definition: xds_interop_client.py:113
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
absl::SetFlagsUsageConfig
void SetFlagsUsageConfig(FlagsUsageConfig usage_config)
Definition: abseil-cpp/absl/flags/usage_config.cc:138
initializaion_order_fiasco_test
bool initializaion_order_fiasco_test
Definition: bloaty/third_party/abseil-cpp/absl/flags/flag_test.cc:854
UDT::UDT
UDT()=default
uint64_t
unsigned __int64 uint64_t
Definition: stdint-msvc2008.h:90
absl::flags_internal::FlagHelpMsg
Definition: abseil-cpp/absl/flags/internal/flag.h:203
absl::Duration
Definition: third_party/abseil-cpp/absl/time/time.h:159
absl::flags_internal::FlagRegistrar
Definition: abseil-cpp/absl/flags/internal/flag.h:775
absl::GetFlag
ABSL_MUST_USE_RESULT T GetFlag(const absl::Flag< T > &flag)
Definition: abseil-cpp/absl/flags/flag.h:98
google::protobuf::compiler::cpp::DefaultValue
std::string DefaultValue(const FieldDescriptor *field)
Definition: bloaty/third_party/protobuf/src/google/protobuf/compiler/cpp/cpp_helpers.cc:622
a_
arena< N > & a_
Definition: cxa_demangle.cpp:4778
absl::FlagsUsageConfig
Definition: abseil-cpp/absl/flags/usage_config.h:68
b
uint64_t b
Definition: abseil-cpp/absl/container/internal/layout_test.cc:53
EXPECT_DEATH_IF_SUPPORTED
#define EXPECT_DEATH_IF_SUPPORTED(statement, regex)
Definition: bloaty/third_party/googletest/googletest/include/gtest/gtest-death-test.h:335
stdint.h
absl::CommandLineFlag::Filename
virtual std::string Filename() const =0
absl::flags_internal::FlagRegistrar::OnUpdate
FlagRegistrar OnUpdate(FlagCallbackFunc cb) &&
Definition: abseil-cpp/absl/flags/internal/flag.h:782
value
const char * value
Definition: hpack_parser_table.cc:165
absl::Seconds
constexpr Duration Seconds(T n)
Definition: third_party/abseil-cpp/absl/time/time.h:419
ABSL_DECLARE_FLAG
ABSL_DECLARE_FLAG(int64_t, mistyped_int_flag)
ABSL_FLAG
ABSL_FLAG(bool, test_flag_01, true, "test flag 01")
absl::flags_internal::Flag
Definition: abseil-cpp/absl/flags/declare.h:36
absl::Now
ABSL_NAMESPACE_BEGIN Time Now()
Definition: abseil-cpp/absl/time/clock.cc:39
absl::FlagSaver
Definition: abseil-cpp/absl/flags/reflection.h:73
bytes
uint8 bytes[10]
Definition: bloaty/third_party/protobuf/src/google/protobuf/io/coded_stream_unittest.cc:153
absl::flags_internal
Definition: abseil-cpp/absl/flags/commandlineflag.h:40
absl::SkipWhitespace
Definition: abseil-cpp/absl/strings/str_split.h:365
kNumThreads
const int kNumThreads
Definition: thread_stress_test.cc:46
absl::str_format_internal::LengthMod::t
@ t
ABSL_RETIRED_FLAG
ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr")
TEST_CONSTRUCTED_FLAG
#define TEST_CONSTRUCTED_FLAG(T)
Definition: bloaty/third_party/abseil-cpp/absl/flags/flag_test.cc:190
absl::flags_internal::StorageKind
static constexpr FlagValueStorageKind StorageKind()
Definition: abseil-cpp/absl/flags/internal/flag.h:333
AbslParseFlag
bool AbslParseFlag(absl::string_view, UDT *, std::string *)
Definition: bloaty/third_party/abseil-cpp/absl/flags/internal/usage_test.cc:49
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
stop
static const char stop[]
Definition: benchmark-async-pummel.c:35
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
ABSL_FLAG_IMPL_FLAG_PTR
#define ABSL_FLAG_IMPL_FLAG_PTR(flag)
Definition: abseil-cpp/absl/flags/flag.h:200
xds_manager.f2
f2
Definition: xds_manager.py:85
int32_t
signed int int32_t
Definition: stdint-msvc2008.h:77
DEFINE_CONSTRUCTED_FLAG
#define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind)
Definition: bloaty/third_party/abseil-cpp/absl/flags/flag_test.cc:139
absl::EndsWith
bool EndsWith(absl::string_view text, absl::string_view suffix) noexcept
Definition: third_party/abseil-cpp/absl/strings/match.h:68
i
uint64_t i
Definition: abseil-cpp/absl/container/btree_benchmark.cc:230
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 02:58:24