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/numeric/int128.h"
38 #include "absl/strings/match.h"
39 #include "absl/strings/numbers.h"
40 #include "absl/strings/str_cat.h"
41 #include "absl/strings/str_split.h"
42 #include "absl/strings/string_view.h"
43 #include "absl/time/time.h"
44
45 ABSL_DECLARE_FLAG(int64_t, mistyped_int_flag);
46 ABSL_DECLARE_FLAG(std::vector<std::string>, mistyped_string_flag);
47
48 namespace {
49
50 namespace flags = absl::flags_internal;
51
TestHelpMsg()52 std::string TestHelpMsg() { return "dynamic help"; }
53 #if defined(_MSC_VER) && !defined(__clang__)
TestLiteralHelpMsg()54 std::string TestLiteralHelpMsg() { return "literal help"; }
55 #endif
56 template <typename T>
TestMakeDflt(void * dst)57 void TestMakeDflt(void* dst) {
58 new (dst) T{};
59 }
TestCallback()60 void TestCallback() {}
61
62 struct UDT {
63 UDT() = default;
64 UDT(const UDT&) = default;
65 UDT& operator=(const UDT&) = default;
66 };
AbslParseFlag(absl::string_view,UDT *,std::string *)67 bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
AbslUnparseFlag(const UDT &)68 std::string AbslUnparseFlag(const UDT&) { return ""; }
69
70 class FlagTest : public testing::Test {
71 protected:
SetUpTestSuite()72 static void SetUpTestSuite() {
73 // Install a function to normalize filenames before this test is run.
74 absl::FlagsUsageConfig default_config;
75 default_config.normalize_filename = &FlagTest::NormalizeFileName;
76 absl::SetFlagsUsageConfig(default_config);
77 }
78
79 private:
NormalizeFileName(absl::string_view fname)80 static std::string NormalizeFileName(absl::string_view fname) {
81 #ifdef _WIN32
82 std::string normalized(fname);
83 std::replace(normalized.begin(), normalized.end(), '\\', '/');
84 fname = normalized;
85 #endif
86 return std::string(fname);
87 }
88 absl::FlagSaver flag_saver_;
89 };
90
91 struct S1 {
92 S1() = default;
93 S1(const S1&) = default;
94 int32_t f1;
95 int64_t f2;
96 };
97
98 struct S2 {
99 S2() = default;
100 S2(const S2&) = default;
101 int64_t f1;
102 double f2;
103 };
104
TEST_F(FlagTest,Traits)105 TEST_F(FlagTest, Traits) {
106 EXPECT_EQ(flags::StorageKind<int>(),
107 flags::FlagValueStorageKind::kValueAndInitBit);
108 EXPECT_EQ(flags::StorageKind<bool>(),
109 flags::FlagValueStorageKind::kValueAndInitBit);
110 EXPECT_EQ(flags::StorageKind<double>(),
111 flags::FlagValueStorageKind::kOneWordAtomic);
112 EXPECT_EQ(flags::StorageKind<int64_t>(),
113 flags::FlagValueStorageKind::kOneWordAtomic);
114
115 EXPECT_EQ(flags::StorageKind<S1>(),
116 flags::FlagValueStorageKind::kSequenceLocked);
117 EXPECT_EQ(flags::StorageKind<S2>(),
118 flags::FlagValueStorageKind::kSequenceLocked);
119 // Make sure absl::Duration uses the sequence-locked code path. MSVC 2015
120 // doesn't consider absl::Duration to be trivially-copyable so we just
121 // restrict this to clang as it seems to be a well-behaved compiler.
122 #ifdef __clang__
123 EXPECT_EQ(flags::StorageKind<absl::Duration>(),
124 flags::FlagValueStorageKind::kSequenceLocked);
125 #endif
126
127 EXPECT_EQ(flags::StorageKind<std::string>(),
128 flags::FlagValueStorageKind::kAlignedBuffer);
129 EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
130 flags::FlagValueStorageKind::kAlignedBuffer);
131
132 EXPECT_EQ(flags::StorageKind<absl::int128>(),
133 flags::FlagValueStorageKind::kSequenceLocked);
134 EXPECT_EQ(flags::StorageKind<absl::uint128>(),
135 flags::FlagValueStorageKind::kSequenceLocked);
136 }
137
138 // --------------------------------------------------------------------
139
140 constexpr flags::FlagHelpArg help_arg{flags::FlagHelpMsg("literal help"),
141 flags::FlagHelpKind::kLiteral};
142
143 using String = std::string;
144 using int128 = absl::int128;
145 using uint128 = absl::uint128;
146
147 #define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind) \
148 constexpr flags::FlagDefaultArg f1default##T{ \
149 flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind}; \
150 constexpr absl::Flag<T> f1##T{"f1", "file", help_arg, f1default##T}; \
151 ABSL_CONST_INIT absl::Flag<T> f2##T { \
152 "f2", "file", \
153 {flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, \
154 flags::FlagDefaultArg { \
155 flags::FlagDefaultSrc(&TestMakeDflt<T>), \
156 flags::FlagDefaultKind::kGenFunc \
157 } \
158 }
159
160 DEFINE_CONSTRUCTED_FLAG(bool, true, kOneWord);
161 DEFINE_CONSTRUCTED_FLAG(int16_t, 1, kOneWord);
162 DEFINE_CONSTRUCTED_FLAG(uint16_t, 2, kOneWord);
163 DEFINE_CONSTRUCTED_FLAG(int32_t, 3, kOneWord);
164 DEFINE_CONSTRUCTED_FLAG(uint32_t, 4, kOneWord);
165 DEFINE_CONSTRUCTED_FLAG(int64_t, 5, kOneWord);
166 DEFINE_CONSTRUCTED_FLAG(uint64_t, 6, kOneWord);
167 DEFINE_CONSTRUCTED_FLAG(float, 7.8, kOneWord);
168 DEFINE_CONSTRUCTED_FLAG(double, 9.10, kOneWord);
169 DEFINE_CONSTRUCTED_FLAG(String, &TestMakeDflt<String>, kGenFunc);
170 DEFINE_CONSTRUCTED_FLAG(UDT, &TestMakeDflt<UDT>, kGenFunc);
171 DEFINE_CONSTRUCTED_FLAG(int128, 13, kGenFunc);
172 DEFINE_CONSTRUCTED_FLAG(uint128, 14, kGenFunc);
173
174 template <typename T>
TestConstructionFor(const absl::Flag<T> & f1,absl::Flag<T> & f2)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
TEST_F(FlagTest,TestConstruction)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 TEST_CONSTRUCTED_FLAG(int128);
205 TEST_CONSTRUCTED_FLAG(uint128);
206 }
207
208 // --------------------------------------------------------------------
209
210 } // namespace
211
212 ABSL_DECLARE_FLAG(bool, test_flag_01);
213 ABSL_DECLARE_FLAG(int, test_flag_02);
214 ABSL_DECLARE_FLAG(int16_t, test_flag_03);
215 ABSL_DECLARE_FLAG(uint16_t, test_flag_04);
216 ABSL_DECLARE_FLAG(int32_t, test_flag_05);
217 ABSL_DECLARE_FLAG(uint32_t, test_flag_06);
218 ABSL_DECLARE_FLAG(int64_t, test_flag_07);
219 ABSL_DECLARE_FLAG(uint64_t, test_flag_08);
220 ABSL_DECLARE_FLAG(double, test_flag_09);
221 ABSL_DECLARE_FLAG(float, test_flag_10);
222 ABSL_DECLARE_FLAG(std::string, test_flag_11);
223 ABSL_DECLARE_FLAG(absl::Duration, test_flag_12);
224 ABSL_DECLARE_FLAG(absl::int128, test_flag_13);
225 ABSL_DECLARE_FLAG(absl::uint128, test_flag_14);
226
227 namespace {
228
229 #if !ABSL_FLAGS_STRIP_NAMES
230
TEST_F(FlagTest,TestFlagDeclaration)231 TEST_F(FlagTest, TestFlagDeclaration) {
232 // test that we can access flag objects.
233 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
234 "test_flag_01");
235 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
236 "test_flag_02");
237 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
238 "test_flag_03");
239 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
240 "test_flag_04");
241 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
242 "test_flag_05");
243 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
244 "test_flag_06");
245 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
246 "test_flag_07");
247 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
248 "test_flag_08");
249 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
250 "test_flag_09");
251 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
252 "test_flag_10");
253 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
254 "test_flag_11");
255 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
256 "test_flag_12");
257 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_13).Name(),
258 "test_flag_13");
259 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_14).Name(),
260 "test_flag_14");
261 }
262 #endif // !ABSL_FLAGS_STRIP_NAMES
263
264 // --------------------------------------------------------------------
265
266 } // namespace
267
268 ABSL_FLAG(bool, test_flag_01, true, "test flag 01");
269 ABSL_FLAG(int, test_flag_02, 1234, "test flag 02");
270 ABSL_FLAG(int16_t, test_flag_03, -34, "test flag 03");
271 ABSL_FLAG(uint16_t, test_flag_04, 189, "test flag 04");
272 ABSL_FLAG(int32_t, test_flag_05, 10765, "test flag 05");
273 ABSL_FLAG(uint32_t, test_flag_06, 40000, "test flag 06");
274 ABSL_FLAG(int64_t, test_flag_07, -1234567, "test flag 07");
275 ABSL_FLAG(uint64_t, test_flag_08, 9876543, "test flag 08");
276 ABSL_FLAG(double, test_flag_09, -9.876e-50, "test flag 09");
277 ABSL_FLAG(float, test_flag_10, 1.234e12f, "test flag 10");
278 ABSL_FLAG(std::string, test_flag_11, "", "test flag 11");
279 ABSL_FLAG(absl::Duration, test_flag_12, absl::Minutes(10), "test flag 12");
280 ABSL_FLAG(absl::int128, test_flag_13, absl::MakeInt128(-1, 0), "test flag 13");
281 ABSL_FLAG(absl::uint128, test_flag_14, absl::MakeUint128(0, 0xFFFAAABBBCCCDDD),
282 "test flag 14");
283
284 namespace {
285
286 #if !ABSL_FLAGS_STRIP_NAMES
TEST_F(FlagTest,TestFlagDefinition)287 TEST_F(FlagTest, TestFlagDefinition) {
288 absl::string_view expected_file_name = "absl/flags/flag_test.cc";
289
290 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
291 "test_flag_01");
292 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Help(),
293 "test flag 01");
294 EXPECT_TRUE(absl::EndsWith(
295 absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename(),
296 expected_file_name))
297 << absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename();
298
299 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
300 "test_flag_02");
301 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Help(),
302 "test flag 02");
303 EXPECT_TRUE(absl::EndsWith(
304 absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename(),
305 expected_file_name))
306 << absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename();
307
308 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
309 "test_flag_03");
310 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Help(),
311 "test flag 03");
312 EXPECT_TRUE(absl::EndsWith(
313 absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename(),
314 expected_file_name))
315 << absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename();
316
317 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
318 "test_flag_04");
319 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Help(),
320 "test flag 04");
321 EXPECT_TRUE(absl::EndsWith(
322 absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename(),
323 expected_file_name))
324 << absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename();
325
326 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
327 "test_flag_05");
328 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Help(),
329 "test flag 05");
330 EXPECT_TRUE(absl::EndsWith(
331 absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename(),
332 expected_file_name))
333 << absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename();
334
335 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
336 "test_flag_06");
337 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Help(),
338 "test flag 06");
339 EXPECT_TRUE(absl::EndsWith(
340 absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename(),
341 expected_file_name))
342 << absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename();
343
344 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
345 "test_flag_07");
346 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Help(),
347 "test flag 07");
348 EXPECT_TRUE(absl::EndsWith(
349 absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename(),
350 expected_file_name))
351 << absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename();
352
353 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
354 "test_flag_08");
355 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Help(),
356 "test flag 08");
357 EXPECT_TRUE(absl::EndsWith(
358 absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename(),
359 expected_file_name))
360 << absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename();
361
362 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
363 "test_flag_09");
364 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Help(),
365 "test flag 09");
366 EXPECT_TRUE(absl::EndsWith(
367 absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename(),
368 expected_file_name))
369 << absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename();
370
371 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
372 "test_flag_10");
373 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Help(),
374 "test flag 10");
375 EXPECT_TRUE(absl::EndsWith(
376 absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename(),
377 expected_file_name))
378 << absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename();
379
380 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
381 "test_flag_11");
382 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Help(),
383 "test flag 11");
384 EXPECT_TRUE(absl::EndsWith(
385 absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename(),
386 expected_file_name))
387 << absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename();
388
389 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
390 "test_flag_12");
391 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Help(),
392 "test flag 12");
393 EXPECT_TRUE(absl::EndsWith(
394 absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename(),
395 expected_file_name))
396 << absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename();
397
398 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_13).Name(),
399 "test_flag_13");
400 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_13).Help(),
401 "test flag 13");
402 EXPECT_TRUE(absl::EndsWith(
403 absl::GetFlagReflectionHandle(FLAGS_test_flag_13).Filename(),
404 expected_file_name))
405 << absl::GetFlagReflectionHandle(FLAGS_test_flag_13).Filename();
406
407 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_14).Name(),
408 "test_flag_14");
409 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_14).Help(),
410 "test flag 14");
411 EXPECT_TRUE(absl::EndsWith(
412 absl::GetFlagReflectionHandle(FLAGS_test_flag_14).Filename(),
413 expected_file_name))
414 << absl::GetFlagReflectionHandle(FLAGS_test_flag_14).Filename();
415 }
416 #endif // !ABSL_FLAGS_STRIP_NAMES
417
418 // --------------------------------------------------------------------
419
TEST_F(FlagTest,TestDefault)420 TEST_F(FlagTest, TestDefault) {
421 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).DefaultValue(),
422 "true");
423 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).DefaultValue(),
424 "1234");
425 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).DefaultValue(),
426 "-34");
427 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).DefaultValue(),
428 "189");
429 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).DefaultValue(),
430 "10765");
431 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).DefaultValue(),
432 "40000");
433 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).DefaultValue(),
434 "-1234567");
435 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).DefaultValue(),
436 "9876543");
437 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).DefaultValue(),
438 "-9.876e-50");
439 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).DefaultValue(),
440 "1.234e+12");
441 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).DefaultValue(),
442 "");
443 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).DefaultValue(),
444 "10m");
445 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_13).DefaultValue(),
446 "-18446744073709551616");
447 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_14).DefaultValue(),
448 "1152827684197027293");
449
450 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).CurrentValue(),
451 "true");
452 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).CurrentValue(),
453 "1234");
454 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).CurrentValue(),
455 "-34");
456 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).CurrentValue(),
457 "189");
458 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).CurrentValue(),
459 "10765");
460 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).CurrentValue(),
461 "40000");
462 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).CurrentValue(),
463 "-1234567");
464 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).CurrentValue(),
465 "9876543");
466 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).CurrentValue(),
467 "-9.876e-50");
468 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).CurrentValue(),
469 "1.234e+12");
470 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).CurrentValue(),
471 "");
472 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).CurrentValue(),
473 "10m");
474 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_13).CurrentValue(),
475 "-18446744073709551616");
476 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_14).CurrentValue(),
477 "1152827684197027293");
478
479 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true);
480 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234);
481 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34);
482 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189);
483 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765);
484 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000);
485 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567);
486 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
487 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55);
488 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f);
489 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "");
490 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10));
491 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), absl::MakeInt128(-1, 0));
492 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14),
493 absl::MakeUint128(0, 0xFFFAAABBBCCCDDD));
494 }
495
496 // --------------------------------------------------------------------
497
498 struct NonTriviallyCopyableAggregate {
499 NonTriviallyCopyableAggregate() = default;
NonTriviallyCopyableAggregate__anonb7a44f4e0311::NonTriviallyCopyableAggregate500 NonTriviallyCopyableAggregate(const NonTriviallyCopyableAggregate& rhs)
501 : value(rhs.value) {}
operator =__anonb7a44f4e0311::NonTriviallyCopyableAggregate502 NonTriviallyCopyableAggregate& operator=(
503 const NonTriviallyCopyableAggregate& rhs) {
504 value = rhs.value;
505 return *this;
506 }
507
508 int value;
509 };
AbslParseFlag(absl::string_view src,NonTriviallyCopyableAggregate * f,std::string * e)510 bool AbslParseFlag(absl::string_view src, NonTriviallyCopyableAggregate* f,
511 std::string* e) {
512 return absl::ParseFlag(src, &f->value, e);
513 }
AbslUnparseFlag(const NonTriviallyCopyableAggregate & ntc)514 std::string AbslUnparseFlag(const NonTriviallyCopyableAggregate& ntc) {
515 return absl::StrCat(ntc.value);
516 }
517
operator ==(const NonTriviallyCopyableAggregate & ntc1,const NonTriviallyCopyableAggregate & ntc2)518 bool operator==(const NonTriviallyCopyableAggregate& ntc1,
519 const NonTriviallyCopyableAggregate& ntc2) {
520 return ntc1.value == ntc2.value;
521 }
522
523 } // namespace
524
525 ABSL_FLAG(bool, test_flag_eb_01, {}, "");
526 ABSL_FLAG(int32_t, test_flag_eb_02, {}, "");
527 ABSL_FLAG(int64_t, test_flag_eb_03, {}, "");
528 ABSL_FLAG(double, test_flag_eb_04, {}, "");
529 ABSL_FLAG(std::string, test_flag_eb_05, {}, "");
530 ABSL_FLAG(NonTriviallyCopyableAggregate, test_flag_eb_06, {}, "");
531
532 namespace {
533
TEST_F(FlagTest,TestEmptyBracesDefault)534 TEST_F(FlagTest, TestEmptyBracesDefault) {
535 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_01).DefaultValue(),
536 "false");
537 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_02).DefaultValue(),
538 "0");
539 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_03).DefaultValue(),
540 "0");
541 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_04).DefaultValue(),
542 "0");
543 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_05).DefaultValue(),
544 "");
545 EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_06).DefaultValue(),
546 "0");
547
548 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_01), false);
549 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_02), 0);
550 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_03), 0);
551 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_04), 0.0);
552 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_05), "");
553 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_06),
554 NonTriviallyCopyableAggregate{});
555 }
556
557 // --------------------------------------------------------------------
558
TEST_F(FlagTest,TestGetSet)559 TEST_F(FlagTest, TestGetSet) {
560 absl::SetFlag(&FLAGS_test_flag_01, false);
561 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), false);
562
563 absl::SetFlag(&FLAGS_test_flag_02, 321);
564 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 321);
565
566 absl::SetFlag(&FLAGS_test_flag_03, 67);
567 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), 67);
568
569 absl::SetFlag(&FLAGS_test_flag_04, 1);
570 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 1);
571
572 absl::SetFlag(&FLAGS_test_flag_05, -908);
573 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), -908);
574
575 absl::SetFlag(&FLAGS_test_flag_06, 4001);
576 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 4001);
577
578 absl::SetFlag(&FLAGS_test_flag_07, -23456);
579 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -23456);
580
581 absl::SetFlag(&FLAGS_test_flag_08, 975310);
582 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 975310);
583
584 absl::SetFlag(&FLAGS_test_flag_09, 1.00001);
585 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), 1.00001, 1e-10);
586
587 absl::SetFlag(&FLAGS_test_flag_10, -3.54f);
588 EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), -3.54f, 1e-6f);
589
590 absl::SetFlag(&FLAGS_test_flag_11, "asdf");
591 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "asdf");
592
593 absl::SetFlag(&FLAGS_test_flag_12, absl::Seconds(110));
594 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Seconds(110));
595
596 absl::SetFlag(&FLAGS_test_flag_13, absl::MakeInt128(-1, 0));
597 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_13), absl::MakeInt128(-1, 0));
598
599 absl::SetFlag(&FLAGS_test_flag_14, absl::MakeUint128(0, 0xFFFAAABBBCCCDDD));
600 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_14),
601 absl::MakeUint128(0, 0xFFFAAABBBCCCDDD));
602 }
603
604 // --------------------------------------------------------------------
605
TEST_F(FlagTest,TestGetViaReflection)606 TEST_F(FlagTest, TestGetViaReflection) {
607 auto* handle = absl::FindCommandLineFlag("test_flag_01");
608 EXPECT_EQ(*handle->TryGet<bool>(), true);
609 handle = absl::FindCommandLineFlag("test_flag_02");
610 EXPECT_EQ(*handle->TryGet<int>(), 1234);
611 handle = absl::FindCommandLineFlag("test_flag_03");
612 EXPECT_EQ(*handle->TryGet<int16_t>(), -34);
613 handle = absl::FindCommandLineFlag("test_flag_04");
614 EXPECT_EQ(*handle->TryGet<uint16_t>(), 189);
615 handle = absl::FindCommandLineFlag("test_flag_05");
616 EXPECT_EQ(*handle->TryGet<int32_t>(), 10765);
617 handle = absl::FindCommandLineFlag("test_flag_06");
618 EXPECT_EQ(*handle->TryGet<uint32_t>(), 40000);
619 handle = absl::FindCommandLineFlag("test_flag_07");
620 EXPECT_EQ(*handle->TryGet<int64_t>(), -1234567);
621 handle = absl::FindCommandLineFlag("test_flag_08");
622 EXPECT_EQ(*handle->TryGet<uint64_t>(), 9876543);
623 handle = absl::FindCommandLineFlag("test_flag_09");
624 EXPECT_NEAR(*handle->TryGet<double>(), -9.876e-50, 1e-55);
625 handle = absl::FindCommandLineFlag("test_flag_10");
626 EXPECT_NEAR(*handle->TryGet<float>(), 1.234e12f, 1e5f);
627 handle = absl::FindCommandLineFlag("test_flag_11");
628 EXPECT_EQ(*handle->TryGet<std::string>(), "");
629 handle = absl::FindCommandLineFlag("test_flag_12");
630 EXPECT_EQ(*handle->TryGet<absl::Duration>(), absl::Minutes(10));
631 handle = absl::FindCommandLineFlag("test_flag_13");
632 EXPECT_EQ(*handle->TryGet<absl::int128>(), absl::MakeInt128(-1, 0));
633 handle = absl::FindCommandLineFlag("test_flag_14");
634 EXPECT_EQ(*handle->TryGet<absl::uint128>(),
635 absl::MakeUint128(0, 0xFFFAAABBBCCCDDD));
636 }
637
638 // --------------------------------------------------------------------
639
TEST_F(FlagTest,ConcurrentSetAndGet)640 TEST_F(FlagTest, ConcurrentSetAndGet) {
641 static constexpr int kNumThreads = 8;
642 // Two arbitrary durations. One thread will concurrently flip the flag
643 // between these two values, while the other threads read it and verify
644 // that no other value is seen.
645 static const absl::Duration kValidDurations[] = {
646 absl::Seconds(int64_t{0x6cebf47a9b68c802}) + absl::Nanoseconds(229702057),
647 absl::Seconds(int64_t{0x23fec0307e4e9d3}) + absl::Nanoseconds(44555374)};
648 absl::SetFlag(&FLAGS_test_flag_12, kValidDurations[0]);
649
650 std::atomic<bool> stop{false};
651 std::vector<std::thread> threads;
652 auto* handle = absl::FindCommandLineFlag("test_flag_12");
653 for (int i = 0; i < kNumThreads; i++) {
654 threads.emplace_back([&]() {
655 while (!stop.load(std::memory_order_relaxed)) {
656 // Try loading the flag both directly and via a reflection
657 // handle.
658 absl::Duration v = absl::GetFlag(FLAGS_test_flag_12);
659 EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
660 v = *handle->TryGet<absl::Duration>();
661 EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
662 }
663 });
664 }
665 absl::Time end_time = absl::Now() + absl::Seconds(1);
666 int i = 0;
667 while (absl::Now() < end_time) {
668 absl::SetFlag(&FLAGS_test_flag_12,
669 kValidDurations[i++ % ABSL_ARRAYSIZE(kValidDurations)]);
670 }
671 stop.store(true, std::memory_order_relaxed);
672 for (auto& t : threads) t.join();
673 }
674
675 // --------------------------------------------------------------------
676
GetDflt1()677 int GetDflt1() { return 1; }
678
679 } // namespace
680
681 ABSL_FLAG(int, test_int_flag_with_non_const_default, GetDflt1(),
682 "test int flag non const default");
683 ABSL_FLAG(std::string, test_string_flag_with_non_const_default,
684 absl::StrCat("AAA", "BBB"), "test string flag non const default");
685
686 namespace {
687
TEST_F(FlagTest,TestNonConstexprDefault)688 TEST_F(FlagTest, TestNonConstexprDefault) {
689 EXPECT_EQ(absl::GetFlag(FLAGS_test_int_flag_with_non_const_default), 1);
690 EXPECT_EQ(absl::GetFlag(FLAGS_test_string_flag_with_non_const_default),
691 "AAABBB");
692 }
693
694 // --------------------------------------------------------------------
695
696 } // namespace
697
698 ABSL_FLAG(bool, test_flag_with_non_const_help, true,
699 absl::StrCat("test ", "flag ", "non const help"));
700
701 namespace {
702
703 #if !ABSL_FLAGS_STRIP_HELP
TEST_F(FlagTest,TestNonConstexprHelp)704 TEST_F(FlagTest, TestNonConstexprHelp) {
705 EXPECT_EQ(
706 absl::GetFlagReflectionHandle(FLAGS_test_flag_with_non_const_help).Help(),
707 "test flag non const help");
708 }
709 #endif //! ABSL_FLAGS_STRIP_HELP
710
711 // --------------------------------------------------------------------
712
713 int cb_test_value = -1;
714 void TestFlagCB();
715
716 } // namespace
717
718 ABSL_FLAG(int, test_flag_with_cb, 100, "").OnUpdate(TestFlagCB);
719
__anonb7a44f4e0802() 720 ABSL_FLAG(int, test_flag_with_lambda_cb, 200, "").OnUpdate([]() {
721 cb_test_value = absl::GetFlag(FLAGS_test_flag_with_lambda_cb) +
722 absl::GetFlag(FLAGS_test_flag_with_cb);
723 });
724
725 namespace {
726
TestFlagCB()727 void TestFlagCB() { cb_test_value = absl::GetFlag(FLAGS_test_flag_with_cb); }
728
729 // Tests side-effects of callback invocation.
TEST_F(FlagTest,CallbackInvocation)730 TEST_F(FlagTest, CallbackInvocation) {
731 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_cb), 100);
732 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_lambda_cb), 200);
733 EXPECT_EQ(cb_test_value, 300);
734
735 absl::SetFlag(&FLAGS_test_flag_with_cb, 1);
736 EXPECT_EQ(cb_test_value, 1);
737
738 absl::SetFlag(&FLAGS_test_flag_with_lambda_cb, 3);
739 EXPECT_EQ(cb_test_value, 4);
740 }
741
742 // --------------------------------------------------------------------
743
744 struct CustomUDT {
CustomUDT__anonb7a44f4e0911::CustomUDT745 CustomUDT() : a(1), b(1) {}
CustomUDT__anonb7a44f4e0911::CustomUDT746 CustomUDT(int a_, int b_) : a(a_), b(b_) {}
747
operator ==(const CustomUDT & f1,const CustomUDT & f2)748 friend bool operator==(const CustomUDT& f1, const CustomUDT& f2) {
749 return f1.a == f2.a && f1.b == f2.b;
750 }
751
752 int a;
753 int b;
754 };
AbslParseFlag(absl::string_view in,CustomUDT * f,std::string *)755 bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) {
756 std::vector<absl::string_view> parts =
757 absl::StrSplit(in, ':', absl::SkipWhitespace());
758
759 if (parts.size() != 2) return false;
760
761 if (!absl::SimpleAtoi(parts[0], &f->a)) return false;
762
763 if (!absl::SimpleAtoi(parts[1], &f->b)) return false;
764
765 return true;
766 }
AbslUnparseFlag(const CustomUDT & f)767 std::string AbslUnparseFlag(const CustomUDT& f) {
768 return absl::StrCat(f.a, ":", f.b);
769 }
770
771 } // namespace
772
773 ABSL_FLAG(CustomUDT, test_flag_custom_udt, CustomUDT(), "test flag custom UDT");
774
775 namespace {
776
TEST_F(FlagTest,TestCustomUDT)777 TEST_F(FlagTest, TestCustomUDT) {
778 EXPECT_EQ(flags::StorageKind<CustomUDT>(),
779 flags::FlagValueStorageKind::kOneWordAtomic);
780 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(1, 1));
781 absl::SetFlag(&FLAGS_test_flag_custom_udt, CustomUDT(2, 3));
782 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(2, 3));
783 }
784
785 // MSVC produces link error on the type mismatch.
786 // Linux does not have build errors and validations work as expected.
787 #if !defined(_WIN32) && GTEST_HAS_DEATH_TEST
788
789 using FlagDeathTest = FlagTest;
790
TEST_F(FlagDeathTest,TestTypeMismatchValidations)791 TEST_F(FlagDeathTest, TestTypeMismatchValidations) {
792 #if !defined(NDEBUG)
793 EXPECT_DEATH_IF_SUPPORTED(
794 static_cast<void>(absl::GetFlag(FLAGS_mistyped_int_flag)),
795 "Flag 'mistyped_int_flag' is defined as one type and declared "
796 "as another");
797 EXPECT_DEATH_IF_SUPPORTED(
798 static_cast<void>(absl::GetFlag(FLAGS_mistyped_string_flag)),
799 "Flag 'mistyped_string_flag' is defined as one type and "
800 "declared as another");
801 #endif
802
803 EXPECT_DEATH_IF_SUPPORTED(
804 absl::SetFlag(&FLAGS_mistyped_int_flag, 1),
805 "Flag 'mistyped_int_flag' is defined as one type and declared "
806 "as another");
807 EXPECT_DEATH_IF_SUPPORTED(
808 absl::SetFlag(&FLAGS_mistyped_string_flag, std::vector<std::string>{}),
809 "Flag 'mistyped_string_flag' is defined as one type and declared as "
810 "another");
811 }
812
813 #endif
814
815 // --------------------------------------------------------------------
816
817 // A contrived type that offers implicit and explicit conversion from specific
818 // source types.
819 struct ConversionTestVal {
820 ConversionTestVal() = default;
ConversionTestVal__anonb7a44f4e0a11::ConversionTestVal821 explicit ConversionTestVal(int a_in) : a(a_in) {}
822
823 enum class ViaImplicitConv { kTen = 10, kEleven };
824 // NOLINTNEXTLINE
ConversionTestVal__anonb7a44f4e0a11::ConversionTestVal825 ConversionTestVal(ViaImplicitConv from) : a(static_cast<int>(from)) {}
826
827 int a;
828 };
829
AbslParseFlag(absl::string_view in,ConversionTestVal * val_out,std::string *)830 bool AbslParseFlag(absl::string_view in, ConversionTestVal* val_out,
831 std::string*) {
832 if (!absl::SimpleAtoi(in, &val_out->a)) {
833 return false;
834 }
835 return true;
836 }
AbslUnparseFlag(const ConversionTestVal & val)837 std::string AbslUnparseFlag(const ConversionTestVal& val) {
838 return absl::StrCat(val.a);
839 }
840
841 } // namespace
842
843 // Flag default values can be specified with a value that converts to the flag
844 // value type implicitly.
845 ABSL_FLAG(ConversionTestVal, test_flag_implicit_conv,
846 ConversionTestVal::ViaImplicitConv::kTen,
847 "test flag init via implicit conversion");
848
849 namespace {
850
TEST_F(FlagTest,CanSetViaImplicitConversion)851 TEST_F(FlagTest, CanSetViaImplicitConversion) {
852 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 10);
853 absl::SetFlag(&FLAGS_test_flag_implicit_conv,
854 ConversionTestVal::ViaImplicitConv::kEleven);
855 EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 11);
856 }
857
858 // --------------------------------------------------------------------
859
860 struct NonDfltConstructible {
861 public:
862 // This constructor tests that we can initialize the flag with int value
NonDfltConstructible__anonb7a44f4e0b11::NonDfltConstructible863 NonDfltConstructible(int i) : value(i) {} // NOLINT
864
865 // This constructor tests that we can't initialize the flag with char value
866 // but can with explicitly constructed NonDfltConstructible.
NonDfltConstructible__anonb7a44f4e0b11::NonDfltConstructible867 explicit NonDfltConstructible(char c) : value(100 + static_cast<int>(c)) {}
868
869 int value;
870 };
871
AbslParseFlag(absl::string_view in,NonDfltConstructible * ndc_out,std::string *)872 bool AbslParseFlag(absl::string_view in, NonDfltConstructible* ndc_out,
873 std::string*) {
874 return absl::SimpleAtoi(in, &ndc_out->value);
875 }
AbslUnparseFlag(const NonDfltConstructible & ndc)876 std::string AbslUnparseFlag(const NonDfltConstructible& ndc) {
877 return absl::StrCat(ndc.value);
878 }
879
880 } // namespace
881
882 ABSL_FLAG(NonDfltConstructible, ndc_flag1, NonDfltConstructible('1'),
883 "Flag with non default constructible type");
884 ABSL_FLAG(NonDfltConstructible, ndc_flag2, 0,
885 "Flag with non default constructible type");
886
887 namespace {
888
TEST_F(FlagTest,TestNonDefaultConstructibleType)889 TEST_F(FlagTest, TestNonDefaultConstructibleType) {
890 EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, '1' + 100);
891 EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 0);
892
893 absl::SetFlag(&FLAGS_ndc_flag1, NonDfltConstructible('A'));
894 absl::SetFlag(&FLAGS_ndc_flag2, 25);
895
896 EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, 'A' + 100);
897 EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 25);
898 }
899
900 } // namespace
901
902 // --------------------------------------------------------------------
903
904 ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr");
905 ABSL_RETIRED_FLAG(int, old_int_flag, (int)std::sqrt(10), "old descr");
906 ABSL_RETIRED_FLAG(std::string, old_str_flag, "", absl::StrCat("old ", "descr"));
907
908 namespace {
909
__anonb7a44f4e0e02null910 bool initialization_order_fiasco_test ABSL_ATTRIBUTE_UNUSED = [] {
911 // Iterate over all the flags during static initialization.
912 // This should not trigger ASan's initialization-order-fiasco.
913 auto* handle1 = absl::FindCommandLineFlag("flag_on_separate_file");
914 auto* handle2 = absl::FindCommandLineFlag("retired_flag_on_separate_file");
915 if (handle1 != nullptr && handle2 != nullptr) {
916 return handle1->Name() == handle2->Name();
917 }
918 return true;
919 }();
920
TEST_F(FlagTest,TestRetiredFlagRegistration)921 TEST_F(FlagTest, TestRetiredFlagRegistration) {
922 auto* handle = absl::FindCommandLineFlag("old_bool_flag");
923 EXPECT_TRUE(handle->IsOfType<bool>());
924 EXPECT_TRUE(handle->IsRetired());
925 handle = absl::FindCommandLineFlag("old_int_flag");
926 EXPECT_TRUE(handle->IsOfType<int>());
927 EXPECT_TRUE(handle->IsRetired());
928 handle = absl::FindCommandLineFlag("old_str_flag");
929 EXPECT_TRUE(handle->IsOfType<std::string>());
930 EXPECT_TRUE(handle->IsRetired());
931 }
932
933 } // namespace
934
935 // --------------------------------------------------------------------
936
937 namespace {
938
939 // User-defined type with small alignment, but size exceeding 16.
940 struct SmallAlignUDT {
SmallAlignUDT__anonb7a44f4e0f11::SmallAlignUDT941 SmallAlignUDT() : c('A'), s(12) {}
942 char c;
943 int16_t s;
944 char bytes[14];
945 };
946
AbslParseFlag(absl::string_view,SmallAlignUDT *,std::string *)947 bool AbslParseFlag(absl::string_view, SmallAlignUDT*, std::string*) {
948 return true;
949 }
AbslUnparseFlag(const SmallAlignUDT &)950 std::string AbslUnparseFlag(const SmallAlignUDT&) { return ""; }
951
952 // User-defined type with small size, but not trivially copyable.
953 struct NonTriviallyCopyableUDT {
NonTriviallyCopyableUDT__anonb7a44f4e0f11::NonTriviallyCopyableUDT954 NonTriviallyCopyableUDT() : c('A') {}
NonTriviallyCopyableUDT__anonb7a44f4e0f11::NonTriviallyCopyableUDT955 NonTriviallyCopyableUDT(const NonTriviallyCopyableUDT& rhs) : c(rhs.c) {}
operator =__anonb7a44f4e0f11::NonTriviallyCopyableUDT956 NonTriviallyCopyableUDT& operator=(const NonTriviallyCopyableUDT& rhs) {
957 c = rhs.c;
958 return *this;
959 }
960
961 char c;
962 };
963
AbslParseFlag(absl::string_view,NonTriviallyCopyableUDT *,std::string *)964 bool AbslParseFlag(absl::string_view, NonTriviallyCopyableUDT*, std::string*) {
965 return true;
966 }
AbslUnparseFlag(const NonTriviallyCopyableUDT &)967 std::string AbslUnparseFlag(const NonTriviallyCopyableUDT&) { return ""; }
968
969 } // namespace
970
971 ABSL_FLAG(SmallAlignUDT, test_flag_sa_udt, {}, "help");
972 ABSL_FLAG(NonTriviallyCopyableUDT, test_flag_ntc_udt, {}, "help");
973
974 namespace {
975
TEST_F(FlagTest,TestSmallAlignUDT)976 TEST_F(FlagTest, TestSmallAlignUDT) {
977 SmallAlignUDT value = absl::GetFlag(FLAGS_test_flag_sa_udt);
978 EXPECT_EQ(value.c, 'A');
979 EXPECT_EQ(value.s, 12);
980
981 value.c = 'B';
982 value.s = 45;
983 absl::SetFlag(&FLAGS_test_flag_sa_udt, value);
984 value = absl::GetFlag(FLAGS_test_flag_sa_udt);
985 EXPECT_EQ(value.c, 'B');
986 EXPECT_EQ(value.s, 45);
987 }
988
TEST_F(FlagTest,TestNonTriviallyCopyableUDT)989 TEST_F(FlagTest, TestNonTriviallyCopyableUDT) {
990 NonTriviallyCopyableUDT value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
991 EXPECT_EQ(value.c, 'A');
992
993 value.c = 'B';
994 absl::SetFlag(&FLAGS_test_flag_ntc_udt, value);
995 value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
996 EXPECT_EQ(value.c, 'B');
997 }
998
999 } // namespace
1000
1001 // --------------------------------------------------------------------
1002
1003 namespace {
1004
1005 enum TestE { A = 1, B = 2, C = 3 };
1006
1007 struct EnumWrapper {
EnumWrapper__anonb7a44f4e1111::EnumWrapper1008 EnumWrapper() : e(A) {}
1009
1010 TestE e;
1011 };
1012
AbslParseFlag(absl::string_view,EnumWrapper *,std::string *)1013 bool AbslParseFlag(absl::string_view, EnumWrapper*, std::string*) {
1014 return true;
1015 }
AbslUnparseFlag(const EnumWrapper &)1016 std::string AbslUnparseFlag(const EnumWrapper&) { return ""; }
1017
1018 } // namespace
1019
1020 ABSL_FLAG(EnumWrapper, test_enum_wrapper_flag, {}, "help");
1021
TEST_F(FlagTest,TesTypeWrappingEnum)1022 TEST_F(FlagTest, TesTypeWrappingEnum) {
1023 EnumWrapper value = absl::GetFlag(FLAGS_test_enum_wrapper_flag);
1024 EXPECT_EQ(value.e, A);
1025
1026 value.e = B;
1027 absl::SetFlag(&FLAGS_test_enum_wrapper_flag, value);
1028 value = absl::GetFlag(FLAGS_test_enum_wrapper_flag);
1029 EXPECT_EQ(value.e, B);
1030 }
1031
1032 // This is a compile test to ensure macros are expanded within ABSL_FLAG and
1033 // ABSL_DECLARE_FLAG.
1034 #define FLAG_NAME_MACRO(name) prefix_##name
1035 ABSL_DECLARE_FLAG(int, FLAG_NAME_MACRO(test_macro_named_flag));
1036 ABSL_FLAG(int, FLAG_NAME_MACRO(test_macro_named_flag), 0,
1037 "Testing macro expansion within ABSL_FLAG");
1038
TEST_F(FlagTest,MacroWithinAbslFlag)1039 TEST_F(FlagTest, MacroWithinAbslFlag) {
1040 EXPECT_EQ(absl::GetFlag(FLAGS_prefix_test_macro_named_flag), 0);
1041 absl::SetFlag(&FLAGS_prefix_test_macro_named_flag, 1);
1042 EXPECT_EQ(absl::GetFlag(FLAGS_prefix_test_macro_named_flag), 1);
1043 }
1044
1045 // --------------------------------------------------------------------
1046
1047 #if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
1048 #define ABSL_SKIP_OPTIONAL_BOOL_TEST_DUE_TO_GCC_BUG
1049 #endif
1050
1051 #ifndef ABSL_SKIP_OPTIONAL_BOOL_TEST_DUE_TO_GCC_BUG
1052 ABSL_FLAG(absl::optional<bool>, optional_bool, absl::nullopt, "help");
1053 #endif
1054 ABSL_FLAG(absl::optional<int>, optional_int, {}, "help");
1055 ABSL_FLAG(absl::optional<double>, optional_double, 9.3, "help");
1056 ABSL_FLAG(absl::optional<std::string>, optional_string, absl::nullopt, "help");
1057 ABSL_FLAG(absl::optional<absl::Duration>, optional_duration, absl::nullopt,
1058 "help");
1059 ABSL_FLAG(absl::optional<absl::optional<int>>, optional_optional_int,
1060 absl::nullopt, "help");
1061 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
1062 ABSL_FLAG(std::optional<int64_t>, std_optional_int64, std::nullopt, "help");
1063 #endif
1064
1065 namespace {
1066
1067 #ifndef ABSL_SKIP_OPTIONAL_BOOL_TEST_DUE_TO_GCC_BUG
TEST_F(FlagTest,TestOptionalBool)1068 TEST_F(FlagTest, TestOptionalBool) {
1069 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_bool).has_value());
1070 EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), absl::nullopt);
1071
1072 absl::SetFlag(&FLAGS_optional_bool, false);
1073 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_bool).has_value());
1074 EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), false);
1075
1076 absl::SetFlag(&FLAGS_optional_bool, true);
1077 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_bool).has_value());
1078 EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), true);
1079
1080 absl::SetFlag(&FLAGS_optional_bool, absl::nullopt);
1081 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_bool).has_value());
1082 EXPECT_EQ(absl::GetFlag(FLAGS_optional_bool), absl::nullopt);
1083 }
1084
1085 // --------------------------------------------------------------------
1086 #endif
1087
TEST_F(FlagTest,TestOptionalInt)1088 TEST_F(FlagTest, TestOptionalInt) {
1089 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_int).has_value());
1090 EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), absl::nullopt);
1091
1092 absl::SetFlag(&FLAGS_optional_int, 0);
1093 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_int).has_value());
1094 EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), 0);
1095
1096 absl::SetFlag(&FLAGS_optional_int, 10);
1097 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_int).has_value());
1098 EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), 10);
1099
1100 absl::SetFlag(&FLAGS_optional_int, absl::nullopt);
1101 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_int).has_value());
1102 EXPECT_EQ(absl::GetFlag(FLAGS_optional_int), absl::nullopt);
1103 }
1104
1105 // --------------------------------------------------------------------
1106
TEST_F(FlagTest,TestOptionalDouble)1107 TEST_F(FlagTest, TestOptionalDouble) {
1108 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_double).has_value());
1109 EXPECT_DOUBLE_EQ(*absl::GetFlag(FLAGS_optional_double), 9.3);
1110
1111 absl::SetFlag(&FLAGS_optional_double, 0.0);
1112 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_double).has_value());
1113 EXPECT_EQ(absl::GetFlag(FLAGS_optional_double), 0.0);
1114
1115 absl::SetFlag(&FLAGS_optional_double, 1.234);
1116 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_double).has_value());
1117 EXPECT_DOUBLE_EQ(*absl::GetFlag(FLAGS_optional_double), 1.234);
1118
1119 absl::SetFlag(&FLAGS_optional_double, absl::nullopt);
1120 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_double).has_value());
1121 EXPECT_EQ(absl::GetFlag(FLAGS_optional_double), absl::nullopt);
1122 }
1123
1124 // --------------------------------------------------------------------
1125
TEST_F(FlagTest,TestOptionalString)1126 TEST_F(FlagTest, TestOptionalString) {
1127 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_string).has_value());
1128 EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), absl::nullopt);
1129
1130 // Setting optional string to "" leads to undefined behavior.
1131
1132 absl::SetFlag(&FLAGS_optional_string, " ");
1133 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_string).has_value());
1134 EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), " ");
1135
1136 absl::SetFlag(&FLAGS_optional_string, "QWERTY");
1137 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_string).has_value());
1138 EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), "QWERTY");
1139
1140 absl::SetFlag(&FLAGS_optional_string, absl::nullopt);
1141 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_string).has_value());
1142 EXPECT_EQ(absl::GetFlag(FLAGS_optional_string), absl::nullopt);
1143 }
1144
1145 // --------------------------------------------------------------------
1146
TEST_F(FlagTest,TestOptionalDuration)1147 TEST_F(FlagTest, TestOptionalDuration) {
1148 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_duration).has_value());
1149 EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::nullopt);
1150
1151 absl::SetFlag(&FLAGS_optional_duration, absl::ZeroDuration());
1152 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_duration).has_value());
1153 EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::Seconds(0));
1154
1155 absl::SetFlag(&FLAGS_optional_duration, absl::Hours(3));
1156 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_duration).has_value());
1157 EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::Hours(3));
1158
1159 absl::SetFlag(&FLAGS_optional_duration, absl::nullopt);
1160 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_duration).has_value());
1161 EXPECT_EQ(absl::GetFlag(FLAGS_optional_duration), absl::nullopt);
1162 }
1163
1164 // --------------------------------------------------------------------
1165
TEST_F(FlagTest,TestOptionalOptional)1166 TEST_F(FlagTest, TestOptionalOptional) {
1167 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
1168 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::nullopt);
1169
1170 absl::optional<int> nullint{absl::nullopt};
1171
1172 absl::SetFlag(&FLAGS_optional_optional_int, nullint);
1173 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
1174 EXPECT_NE(absl::GetFlag(FLAGS_optional_optional_int), nullint);
1175 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int),
1176 absl::optional<absl::optional<int>>{nullint});
1177
1178 absl::SetFlag(&FLAGS_optional_optional_int, 0);
1179 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
1180 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), 0);
1181
1182 absl::SetFlag(&FLAGS_optional_optional_int, absl::optional<int>{0});
1183 EXPECT_TRUE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
1184 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), 0);
1185 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::optional<int>{0});
1186
1187 absl::SetFlag(&FLAGS_optional_optional_int, absl::nullopt);
1188 EXPECT_FALSE(absl::GetFlag(FLAGS_optional_optional_int).has_value());
1189 EXPECT_EQ(absl::GetFlag(FLAGS_optional_optional_int), absl::nullopt);
1190 }
1191
1192 // --------------------------------------------------------------------
1193
1194 #if defined(ABSL_HAVE_STD_OPTIONAL) && !defined(ABSL_USES_STD_OPTIONAL)
1195
TEST_F(FlagTest,TestStdOptional)1196 TEST_F(FlagTest, TestStdOptional) {
1197 EXPECT_FALSE(absl::GetFlag(FLAGS_std_optional_int64).has_value());
1198 EXPECT_EQ(absl::GetFlag(FLAGS_std_optional_int64), std::nullopt);
1199
1200 absl::SetFlag(&FLAGS_std_optional_int64, 0);
1201 EXPECT_TRUE(absl::GetFlag(FLAGS_std_optional_int64).has_value());
1202 EXPECT_EQ(absl::GetFlag(FLAGS_std_optional_int64), 0);
1203
1204 absl::SetFlag(&FLAGS_std_optional_int64, 0xFFFFFFFFFF16);
1205 EXPECT_TRUE(absl::GetFlag(FLAGS_std_optional_int64).has_value());
1206 EXPECT_EQ(absl::GetFlag(FLAGS_std_optional_int64), 0xFFFFFFFFFF16);
1207
1208 absl::SetFlag(&FLAGS_std_optional_int64, std::nullopt);
1209 EXPECT_FALSE(absl::GetFlag(FLAGS_std_optional_int64).has_value());
1210 EXPECT_EQ(absl::GetFlag(FLAGS_std_optional_int64), std::nullopt);
1211 }
1212
1213 // --------------------------------------------------------------------
1214
1215 #endif
1216
1217 } // namespace
1218