Chiebot-Mirror
/
abseil-cpp
mirror of https://hub.fastgit.xyz/abseil/abseil-cpp.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity
Abseil Common Libraries (C++) (grcp 依赖) https://abseil.io/
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
258 Commits
9 Branches
22 Tags
14 MiB
 
 
 
 
 
 
Tag: Branch: Tree: cc413f8b67
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'cc413f8b67'
${ noResults }
abseil-cpp/absl/flags/flag_test.cc

979 lines
34 KiB
Raw Blame History

//
// Copyright 2019 The Abseil Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "absl/flags/flag.h"
#include <stddef.h>
#include <stdint.h>
#include <atomic>
#include <cmath>
#include <new>
#include <string>
#include <thread> // NOLINT
#include <vector>
#include "gtest/gtest.h"
#include "absl/base/attributes.h"
#include "absl/base/macros.h"
#include "absl/flags/config.h"
#include "absl/flags/declare.h"
#include "absl/flags/internal/flag.h"
#include "absl/flags/marshalling.h"
#include "absl/flags/reflection.h"
#include "absl/flags/usage_config.h"
#include "absl/strings/match.h"
#include "absl/strings/numbers.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_split.h"
#include "absl/strings/string_view.h"
#include "absl/time/time.h"
ABSL_DECLARE_FLAG(int64_t, mistyped_int_flag);
ABSL_DECLARE_FLAG(std::vector<std::string>, mistyped_string_flag);
namespace {
namespace flags = absl::flags_internal;
std::string TestHelpMsg() { return "dynamic help"; }
#if defined(_MSC_VER) && !defined(__clang__)
std::string TestLiteralHelpMsg() { return "literal help"; }
#endif
template <typename T>
void TestMakeDflt(void* dst) {
new (dst) T{};
}
void TestCallback() {}
struct UDT {
UDT() = default;
UDT(const UDT&) = default;
UDT& operator=(const UDT&) = default;
};
bool AbslParseFlag(absl::string_view, UDT*, std::string*) { return true; }
std::string AbslUnparseFlag(const UDT&) { return ""; }
class FlagTest : public testing::Test {
protected:
static void SetUpTestSuite() {
// Install a function to normalize filenames before this test is run.
absl::FlagsUsageConfig default_config;
default_config.normalize_filename = &FlagTest::NormalizeFileName;
absl::SetFlagsUsageConfig(default_config);
}
private:
static std::string NormalizeFileName(absl::string_view fname) {
#ifdef _WIN32
std::string normalized(fname);
std::replace(normalized.begin(), normalized.end(), '\\', '/');
fname = normalized;
#endif
return std::string(fname);
}
absl::FlagSaver flag_saver_;
};
struct S1 {
S1() = default;
S1(const S1&) = default;
int32_t f1;
int64_t f2;
};
struct S2 {
S2() = default;
S2(const S2&) = default;
int64_t f1;
double f2;
};
TEST_F(FlagTest, Traits) {
EXPECT_EQ(flags::StorageKind<int>(),
flags::FlagValueStorageKind::kValueAndInitBit);
EXPECT_EQ(flags::StorageKind<bool>(),
flags::FlagValueStorageKind::kValueAndInitBit);
EXPECT_EQ(flags::StorageKind<double>(),
flags::FlagValueStorageKind::kOneWordAtomic);
EXPECT_EQ(flags::StorageKind<int64_t>(),
flags::FlagValueStorageKind::kOneWordAtomic);
EXPECT_EQ(flags::StorageKind<S1>(),
flags::FlagValueStorageKind::kSequenceLocked);
EXPECT_EQ(flags::StorageKind<S2>(),
flags::FlagValueStorageKind::kSequenceLocked);
// Make sure absl::Duration uses the sequence-locked code path. MSVC 2015
// doesn't consider absl::Duration to be trivially-copyable so we just
// restrict this to clang as it seems to be a well-behaved compiler.
#ifdef __clang__
EXPECT_EQ(flags::StorageKind<absl::Duration>(),
flags::FlagValueStorageKind::kSequenceLocked);
#endif
EXPECT_EQ(flags::StorageKind<std::string>(),
flags::FlagValueStorageKind::kAlignedBuffer);
EXPECT_EQ(flags::StorageKind<std::vector<std::string>>(),
flags::FlagValueStorageKind::kAlignedBuffer);
}
// --------------------------------------------------------------------
constexpr flags::FlagHelpArg help_arg{flags::FlagHelpMsg("literal help"),
flags::FlagHelpKind::kLiteral};
using String = std::string;
#if !defined(_MSC_VER) || defined(__clang__)
#define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind) \
constexpr flags::FlagDefaultArg f1default##T{ \
flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind}; \
constexpr absl::Flag<T> f1##T{"f1", "file", help_arg, f1default##T}; \
ABSL_CONST_INIT absl::Flag<T> f2##T { \
"f2", "file", \
{flags::FlagHelpMsg(&TestHelpMsg), flags::FlagHelpKind::kGenFunc}, \
flags::FlagDefaultArg { \
flags::FlagDefaultSrc(&TestMakeDflt<T>), \
flags::FlagDefaultKind::kGenFunc \
} \
}
#else
#define DEFINE_CONSTRUCTED_FLAG(T, dflt, dflt_kind) \
constexpr flags::FlagDefaultArg f1default##T{ \
flags::FlagDefaultSrc{dflt}, flags::FlagDefaultKind::dflt_kind}; \
constexpr absl::Flag<T> f1##T{"f1", "file", &TestLiteralHelpMsg, \
&TestMakeDflt<T>}; \
ABSL_CONST_INIT absl::Flag<T> f2##T { \
"f2", "file", &TestHelpMsg, &TestMakeDflt<T> \
}
#endif
DEFINE_CONSTRUCTED_FLAG(bool, true, kOneWord);
DEFINE_CONSTRUCTED_FLAG(int16_t, 1, kOneWord);
DEFINE_CONSTRUCTED_FLAG(uint16_t, 2, kOneWord);
DEFINE_CONSTRUCTED_FLAG(int32_t, 3, kOneWord);
DEFINE_CONSTRUCTED_FLAG(uint32_t, 4, kOneWord);
DEFINE_CONSTRUCTED_FLAG(int64_t, 5, kOneWord);
DEFINE_CONSTRUCTED_FLAG(uint64_t, 6, kOneWord);
DEFINE_CONSTRUCTED_FLAG(float, 7.8, kOneWord);
DEFINE_CONSTRUCTED_FLAG(double, 9.10, kOneWord);
DEFINE_CONSTRUCTED_FLAG(String, &TestMakeDflt<String>, kGenFunc);
DEFINE_CONSTRUCTED_FLAG(UDT, &TestMakeDflt<UDT>, kGenFunc);
template <typename T>
bool TestConstructionFor(const absl::Flag<T>& f1, absl::Flag<T>& f2) {
EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Name(), "f1");
EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Help(), "literal help");
EXPECT_EQ(absl::GetFlagReflectionHandle(f1).Filename(), "file");
flags::FlagRegistrar<T, false>(ABSL_FLAG_IMPL_FLAG_PTR(f2), nullptr)
.OnUpdate(TestCallback);
EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Name(), "f2");
EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Help(), "dynamic help");
EXPECT_EQ(absl::GetFlagReflectionHandle(f2).Filename(), "file");
return true;
}
#define TEST_CONSTRUCTED_FLAG(T) TestConstructionFor(f1##T, f2##T);
TEST_F(FlagTest, TestConstruction) {
TEST_CONSTRUCTED_FLAG(bool);
TEST_CONSTRUCTED_FLAG(int16_t);
TEST_CONSTRUCTED_FLAG(uint16_t);
TEST_CONSTRUCTED_FLAG(int32_t);
TEST_CONSTRUCTED_FLAG(uint32_t);
TEST_CONSTRUCTED_FLAG(int64_t);
TEST_CONSTRUCTED_FLAG(uint64_t);
TEST_CONSTRUCTED_FLAG(float);
TEST_CONSTRUCTED_FLAG(double);
TEST_CONSTRUCTED_FLAG(String);
TEST_CONSTRUCTED_FLAG(UDT);
}
// --------------------------------------------------------------------
} // namespace
ABSL_DECLARE_FLAG(bool, test_flag_01);
ABSL_DECLARE_FLAG(int, test_flag_02);
ABSL_DECLARE_FLAG(int16_t, test_flag_03);
ABSL_DECLARE_FLAG(uint16_t, test_flag_04);
ABSL_DECLARE_FLAG(int32_t, test_flag_05);
ABSL_DECLARE_FLAG(uint32_t, test_flag_06);
ABSL_DECLARE_FLAG(int64_t, test_flag_07);
ABSL_DECLARE_FLAG(uint64_t, test_flag_08);
ABSL_DECLARE_FLAG(double, test_flag_09);
ABSL_DECLARE_FLAG(float, test_flag_10);
ABSL_DECLARE_FLAG(std::string, test_flag_11);
ABSL_DECLARE_FLAG(absl::Duration, test_flag_12);
namespace {
#if !ABSL_FLAGS_STRIP_NAMES
TEST_F(FlagTest, TestFlagDeclaration) {
// test that we can access flag objects.
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
"test_flag_01");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
"test_flag_02");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
"test_flag_03");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
"test_flag_04");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
"test_flag_05");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
"test_flag_06");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
"test_flag_07");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
"test_flag_08");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
"test_flag_09");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
"test_flag_10");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
"test_flag_11");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
"test_flag_12");
}
#endif // !ABSL_FLAGS_STRIP_NAMES
// --------------------------------------------------------------------
} // namespace
ABSL_FLAG(bool, test_flag_01, true, "test flag 01");
ABSL_FLAG(int, test_flag_02, 1234, "test flag 02");
ABSL_FLAG(int16_t, test_flag_03, -34, "test flag 03");
ABSL_FLAG(uint16_t, test_flag_04, 189, "test flag 04");
ABSL_FLAG(int32_t, test_flag_05, 10765, "test flag 05");
ABSL_FLAG(uint32_t, test_flag_06, 40000, "test flag 06");
ABSL_FLAG(int64_t, test_flag_07, -1234567, "test flag 07");
ABSL_FLAG(uint64_t, test_flag_08, 9876543, "test flag 08");
ABSL_FLAG(double, test_flag_09, -9.876e-50, "test flag 09");
ABSL_FLAG(float, test_flag_10, 1.234e12f, "test flag 10");
ABSL_FLAG(std::string, test_flag_11, "", "test flag 11");
ABSL_FLAG(absl::Duration, test_flag_12, absl::Minutes(10), "test flag 12");
namespace {
#if !ABSL_FLAGS_STRIP_NAMES
TEST_F(FlagTest, TestFlagDefinition) {
absl::string_view expected_file_name = "absl/flags/flag_test.cc";
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Name(),
"test_flag_01");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Help(),
"test flag 01");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_01).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Name(),
"test_flag_02");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Help(),
"test flag 02");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_02).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Name(),
"test_flag_03");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Help(),
"test flag 03");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_03).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Name(),
"test_flag_04");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Help(),
"test flag 04");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_04).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Name(),
"test_flag_05");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Help(),
"test flag 05");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_05).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Name(),
"test_flag_06");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Help(),
"test flag 06");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_06).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Name(),
"test_flag_07");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Help(),
"test flag 07");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_07).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Name(),
"test_flag_08");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Help(),
"test flag 08");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_08).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Name(),
"test_flag_09");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Help(),
"test flag 09");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_09).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Name(),
"test_flag_10");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Help(),
"test flag 10");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_10).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Name(),
"test_flag_11");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Help(),
"test flag 11");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_11).Filename();
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Name(),
"test_flag_12");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Help(),
"test flag 12");
EXPECT_TRUE(absl::EndsWith(
absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename(),
expected_file_name))
<< absl::GetFlagReflectionHandle(FLAGS_test_flag_12).Filename();
}
#endif // !ABSL_FLAGS_STRIP_NAMES
// --------------------------------------------------------------------
TEST_F(FlagTest, TestDefault) {
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).DefaultValue(),
"true");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).DefaultValue(),
"1234");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).DefaultValue(),
"-34");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).DefaultValue(),
"189");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).DefaultValue(),
"10765");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).DefaultValue(),
"40000");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).DefaultValue(),
"-1234567");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).DefaultValue(),
"9876543");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).DefaultValue(),
"-9.876e-50");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).DefaultValue(),
"1.234e+12");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).DefaultValue(),
"");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).DefaultValue(),
"10m");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_01).CurrentValue(),
"true");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_02).CurrentValue(),
"1234");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_03).CurrentValue(),
"-34");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_04).CurrentValue(),
"189");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_05).CurrentValue(),
"10765");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_06).CurrentValue(),
"40000");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_07).CurrentValue(),
"-1234567");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_08).CurrentValue(),
"9876543");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_09).CurrentValue(),
"-9.876e-50");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_10).CurrentValue(),
"1.234e+12");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_11).CurrentValue(),
"");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_12).CurrentValue(),
"10m");
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), true);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 1234);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), -34);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 189);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), 10765);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 40000);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -1234567);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 9876543);
EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), -9.876e-50, 1e-55);
EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), 1.234e12f, 1e5f);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "");
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Minutes(10));
}
// --------------------------------------------------------------------
struct NonTriviallyCopyableAggregate {
NonTriviallyCopyableAggregate() = default;
NonTriviallyCopyableAggregate(const NonTriviallyCopyableAggregate& rhs)
: value(rhs.value) {}
NonTriviallyCopyableAggregate& operator=(
const NonTriviallyCopyableAggregate& rhs) {
value = rhs.value;
return *this;
}
int value;
};
bool AbslParseFlag(absl::string_view src, NonTriviallyCopyableAggregate* f,
std::string* e) {
return absl::ParseFlag(src, &f->value, e);
}
std::string AbslUnparseFlag(const NonTriviallyCopyableAggregate& ntc) {
return absl::StrCat(ntc.value);
}
bool operator==(const NonTriviallyCopyableAggregate& ntc1,
const NonTriviallyCopyableAggregate& ntc2) {
return ntc1.value == ntc2.value;
}
} // namespace
ABSL_FLAG(bool, test_flag_eb_01, {}, "");
ABSL_FLAG(int32_t, test_flag_eb_02, {}, "");
ABSL_FLAG(int64_t, test_flag_eb_03, {}, "");
ABSL_FLAG(double, test_flag_eb_04, {}, "");
ABSL_FLAG(std::string, test_flag_eb_05, {}, "");
ABSL_FLAG(NonTriviallyCopyableAggregate, test_flag_eb_06, {}, "");
namespace {
TEST_F(FlagTest, TestEmptyBracesDefault) {
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_01).DefaultValue(),
"false");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_02).DefaultValue(),
"0");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_03).DefaultValue(),
"0");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_04).DefaultValue(),
"0");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_05).DefaultValue(),
"");
EXPECT_EQ(absl::GetFlagReflectionHandle(FLAGS_test_flag_eb_06).DefaultValue(),
"0");
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_01), false);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_02), 0);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_03), 0);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_04), 0.0);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_05), "");
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_eb_06),
NonTriviallyCopyableAggregate{});
}
// --------------------------------------------------------------------
TEST_F(FlagTest, TestGetSet) {
absl::SetFlag(&FLAGS_test_flag_01, false);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_01), false);
absl::SetFlag(&FLAGS_test_flag_02, 321);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_02), 321);
absl::SetFlag(&FLAGS_test_flag_03, 67);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_03), 67);
absl::SetFlag(&FLAGS_test_flag_04, 1);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_04), 1);
absl::SetFlag(&FLAGS_test_flag_05, -908);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_05), -908);
absl::SetFlag(&FLAGS_test_flag_06, 4001);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_06), 4001);
absl::SetFlag(&FLAGS_test_flag_07, -23456);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_07), -23456);
absl::SetFlag(&FLAGS_test_flag_08, 975310);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_08), 975310);
absl::SetFlag(&FLAGS_test_flag_09, 1.00001);
EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_09), 1.00001, 1e-10);
absl::SetFlag(&FLAGS_test_flag_10, -3.54f);
EXPECT_NEAR(absl::GetFlag(FLAGS_test_flag_10), -3.54f, 1e-6f);
absl::SetFlag(&FLAGS_test_flag_11, "asdf");
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_11), "asdf");
absl::SetFlag(&FLAGS_test_flag_12, absl::Seconds(110));
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_12), absl::Seconds(110));
}
// --------------------------------------------------------------------
TEST_F(FlagTest, TestGetViaReflection) {
auto* handle = absl::FindCommandLineFlag("test_flag_01");
EXPECT_EQ(*handle->TryGet<bool>(), true);
handle = absl::FindCommandLineFlag("test_flag_02");
EXPECT_EQ(*handle->TryGet<int>(), 1234);
handle = absl::FindCommandLineFlag("test_flag_03");
EXPECT_EQ(*handle->TryGet<int16_t>(), -34);
handle = absl::FindCommandLineFlag("test_flag_04");
EXPECT_EQ(*handle->TryGet<uint16_t>(), 189);
handle = absl::FindCommandLineFlag("test_flag_05");
EXPECT_EQ(*handle->TryGet<int32_t>(), 10765);
handle = absl::FindCommandLineFlag("test_flag_06");
EXPECT_EQ(*handle->TryGet<uint32_t>(), 40000);
handle = absl::FindCommandLineFlag("test_flag_07");
EXPECT_EQ(*handle->TryGet<int64_t>(), -1234567);
handle = absl::FindCommandLineFlag("test_flag_08");
EXPECT_EQ(*handle->TryGet<uint64_t>(), 9876543);
handle = absl::FindCommandLineFlag("test_flag_09");
EXPECT_NEAR(*handle->TryGet<double>(), -9.876e-50, 1e-55);
handle = absl::FindCommandLineFlag("test_flag_10");
EXPECT_NEAR(*handle->TryGet<float>(), 1.234e12f, 1e5f);
handle = absl::FindCommandLineFlag("test_flag_11");
EXPECT_EQ(*handle->TryGet<std::string>(), "");
handle = absl::FindCommandLineFlag("test_flag_12");
EXPECT_EQ(*handle->TryGet<absl::Duration>(), absl::Minutes(10));
}
// --------------------------------------------------------------------
TEST_F(FlagTest, ConcurrentSetAndGet) {
static constexpr int kNumThreads = 8;
// Two arbitrary durations. One thread will concurrently flip the flag
// between these two values, while the other threads read it and verify
// that no other value is seen.
static const absl::Duration kValidDurations[] = {
absl::Seconds(int64_t{0x6cebf47a9b68c802}) + absl::Nanoseconds(229702057),
absl::Seconds(int64_t{0x23fec0307e4e9d3}) + absl::Nanoseconds(44555374)};
absl::SetFlag(&FLAGS_test_flag_12, kValidDurations[0]);
std::atomic<bool> stop{false};
std::vector<std::thread> threads;
auto* handle = absl::FindCommandLineFlag("test_flag_12");
for (int i = 0; i < kNumThreads; i++) {
threads.emplace_back([&]() {
while (!stop.load(std::memory_order_relaxed)) {
// Try loading the flag both directly and via a reflection
// handle.
absl::Duration v = absl::GetFlag(FLAGS_test_flag_12);
EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
v = *handle->TryGet<absl::Duration>();
EXPECT_TRUE(v == kValidDurations[0] || v == kValidDurations[1]);
}
});
}
absl::Time end_time = absl::Now() + absl::Seconds(1);
int i = 0;
while (absl::Now() < end_time) {
absl::SetFlag(&FLAGS_test_flag_12,
kValidDurations[i++ % ABSL_ARRAYSIZE(kValidDurations)]);
}
stop.store(true, std::memory_order_relaxed);
for (auto& t : threads) t.join();
}
// --------------------------------------------------------------------
int GetDflt1() { return 1; }
} // namespace
ABSL_FLAG(int, test_int_flag_with_non_const_default, GetDflt1(),
"test int flag non const default");
ABSL_FLAG(std::string, test_string_flag_with_non_const_default,
absl::StrCat("AAA", "BBB"), "test string flag non const default");
namespace {
TEST_F(FlagTest, TestNonConstexprDefault) {
EXPECT_EQ(absl::GetFlag(FLAGS_test_int_flag_with_non_const_default), 1);
EXPECT_EQ(absl::GetFlag(FLAGS_test_string_flag_with_non_const_default),
"AAABBB");
}
// --------------------------------------------------------------------
} // namespace
ABSL_FLAG(bool, test_flag_with_non_const_help, true,
absl::StrCat("test ", "flag ", "non const help"));
namespace {
#if !ABSL_FLAGS_STRIP_HELP
TEST_F(FlagTest, TestNonConstexprHelp) {
EXPECT_EQ(
absl::GetFlagReflectionHandle(FLAGS_test_flag_with_non_const_help).Help(),
"test flag non const help");
}
#endif //! ABSL_FLAGS_STRIP_HELP
// --------------------------------------------------------------------
int cb_test_value = -1;
void TestFlagCB();
} // namespace
ABSL_FLAG(int, test_flag_with_cb, 100, "").OnUpdate(TestFlagCB);
ABSL_FLAG(int, test_flag_with_lambda_cb, 200, "").OnUpdate([]() {
cb_test_value = absl::GetFlag(FLAGS_test_flag_with_lambda_cb) +
absl::GetFlag(FLAGS_test_flag_with_cb);
});
namespace {
void TestFlagCB() { cb_test_value = absl::GetFlag(FLAGS_test_flag_with_cb); }
// Tests side-effects of callback invocation.
TEST_F(FlagTest, CallbackInvocation) {
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_cb), 100);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_with_lambda_cb), 200);
EXPECT_EQ(cb_test_value, 300);
absl::SetFlag(&FLAGS_test_flag_with_cb, 1);
EXPECT_EQ(cb_test_value, 1);
absl::SetFlag(&FLAGS_test_flag_with_lambda_cb, 3);
EXPECT_EQ(cb_test_value, 4);
}
// --------------------------------------------------------------------
struct CustomUDT {
CustomUDT() : a(1), b(1) {}
CustomUDT(int a_, int b_) : a(a_), b(b_) {}
friend bool operator==(const CustomUDT& f1, const CustomUDT& f2) {
return f1.a == f2.a && f1.b == f2.b;
}
int a;
int b;
};
bool AbslParseFlag(absl::string_view in, CustomUDT* f, std::string*) {
std::vector<absl::string_view> parts =
absl::StrSplit(in, ':', absl::SkipWhitespace());
if (parts.size() != 2) return false;
if (!absl::SimpleAtoi(parts[0], &f->a)) return false;
if (!absl::SimpleAtoi(parts[1], &f->b)) return false;
return true;
}
std::string AbslUnparseFlag(const CustomUDT& f) {
return absl::StrCat(f.a, ":", f.b);
}
} // namespace
ABSL_FLAG(CustomUDT, test_flag_custom_udt, CustomUDT(), "test flag custom UDT");
namespace {
TEST_F(FlagTest, TestCustomUDT) {
EXPECT_EQ(flags::StorageKind<CustomUDT>(),
flags::FlagValueStorageKind::kOneWordAtomic);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(1, 1));
absl::SetFlag(&FLAGS_test_flag_custom_udt, CustomUDT(2, 3));
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_custom_udt), CustomUDT(2, 3));
}
// MSVC produces link error on the type mismatch.
// Linux does not have build errors and validations work as expected.
#if !defined(_WIN32) && GTEST_HAS_DEATH_TEST
using FlagDeathTest = FlagTest;
TEST_F(FlagDeathTest, TestTypeMismatchValidations) {
#if !defined(NDEBUG)
EXPECT_DEATH_IF_SUPPORTED(
static_cast<void>(absl::GetFlag(FLAGS_mistyped_int_flag)),
"Flag 'mistyped_int_flag' is defined as one type and declared "
"as another");
EXPECT_DEATH_IF_SUPPORTED(
static_cast<void>(absl::GetFlag(FLAGS_mistyped_string_flag)),
"Flag 'mistyped_string_flag' is defined as one type and "
"declared as another");
#endif
EXPECT_DEATH_IF_SUPPORTED(
absl::SetFlag(&FLAGS_mistyped_int_flag, 1),
"Flag 'mistyped_int_flag' is defined as one type and declared "
"as another");
EXPECT_DEATH_IF_SUPPORTED(
absl::SetFlag(&FLAGS_mistyped_string_flag, std::vector<std::string>{}),
"Flag 'mistyped_string_flag' is defined as one type and declared as "
"another");
}
#endif
// --------------------------------------------------------------------
// A contrived type that offers implicit and explicit conversion from specific
// source types.
struct ConversionTestVal {
ConversionTestVal() = default;
explicit ConversionTestVal(int a_in) : a(a_in) {}
enum class ViaImplicitConv { kTen = 10, kEleven };
// NOLINTNEXTLINE
ConversionTestVal(ViaImplicitConv from) : a(static_cast<int>(from)) {}
int a;
};
bool AbslParseFlag(absl::string_view in, ConversionTestVal* val_out,
std::string*) {
if (!absl::SimpleAtoi(in, &val_out->a)) {
return false;
}
return true;
}
std::string AbslUnparseFlag(const ConversionTestVal& val) {
return absl::StrCat(val.a);
}
} // namespace
// Flag default values can be specified with a value that converts to the flag
// value type implicitly.
ABSL_FLAG(ConversionTestVal, test_flag_implicit_conv,
ConversionTestVal::ViaImplicitConv::kTen,
"test flag init via implicit conversion");
namespace {
TEST_F(FlagTest, CanSetViaImplicitConversion) {
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 10);
absl::SetFlag(&FLAGS_test_flag_implicit_conv,
ConversionTestVal::ViaImplicitConv::kEleven);
EXPECT_EQ(absl::GetFlag(FLAGS_test_flag_implicit_conv).a, 11);
}
// --------------------------------------------------------------------
struct NonDfltConstructible {
public:
// This constructor tests that we can initialize the flag with int value
NonDfltConstructible(int i) : value(i) {} // NOLINT
// This constructor tests that we can't initialize the flag with char value
// but can with explicitly constructed NonDfltConstructible.
explicit NonDfltConstructible(char c) : value(100 + static_cast<int>(c)) {}
int value;
};
bool AbslParseFlag(absl::string_view in, NonDfltConstructible* ndc_out,
std::string*) {
return absl::SimpleAtoi(in, &ndc_out->value);
}
std::string AbslUnparseFlag(const NonDfltConstructible& ndc) {
return absl::StrCat(ndc.value);
}
} // namespace
ABSL_FLAG(NonDfltConstructible, ndc_flag1, NonDfltConstructible('1'),
"Flag with non default constructible type");
ABSL_FLAG(NonDfltConstructible, ndc_flag2, 0,
"Flag with non default constructible type");
namespace {
TEST_F(FlagTest, TestNonDefaultConstructibleType) {
EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, '1' + 100);
EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 0);
absl::SetFlag(&FLAGS_ndc_flag1, NonDfltConstructible('A'));
absl::SetFlag(&FLAGS_ndc_flag2, 25);
EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag1).value, 'A' + 100);
EXPECT_EQ(absl::GetFlag(FLAGS_ndc_flag2).value, 25);
}
} // namespace
// --------------------------------------------------------------------
ABSL_RETIRED_FLAG(bool, old_bool_flag, true, "old descr");
ABSL_RETIRED_FLAG(int, old_int_flag, (int)std::sqrt(10), "old descr");
ABSL_RETIRED_FLAG(std::string, old_str_flag, "", absl::StrCat("old ", "descr"));
bool initializaion_order_fiasco_test = [] {
// Iterate over all the flags during static initialization.
// This should not trigger ASan's initialization-order-fiasco.
auto* handle1 = absl::FindCommandLineFlag("flag_on_separate_file");
auto* handle2 = absl::FindCommandLineFlag("retired_flag_on_separate_file");
if (handle1 != nullptr && handle2 != nullptr) {
return handle1->Name() == handle2->Name();
}
return true;
}();
namespace {
TEST_F(FlagTest, TestRetiredFlagRegistration) {
auto* handle = absl::FindCommandLineFlag("old_bool_flag");
EXPECT_TRUE(handle->IsOfType<bool>());
EXPECT_TRUE(handle->IsRetired());
handle = absl::FindCommandLineFlag("old_int_flag");
EXPECT_TRUE(handle->IsOfType<int>());
EXPECT_TRUE(handle->IsRetired());
handle = absl::FindCommandLineFlag("old_str_flag");
EXPECT_TRUE(handle->IsOfType<std::string>());
EXPECT_TRUE(handle->IsRetired());
}
} // namespace
// --------------------------------------------------------------------
namespace {
// User-defined type with small alignment, but size exceeding 16.
struct SmallAlignUDT {
SmallAlignUDT() : c('A'), s(12) {}
char c;
int16_t s;
char bytes[14];
};
bool AbslParseFlag(absl::string_view, SmallAlignUDT*, std::string*) {
return true;
}
std::string AbslUnparseFlag(const SmallAlignUDT&) { return ""; }
// User-defined type with small size, but not trivially copyable.
struct NonTriviallyCopyableUDT {
NonTriviallyCopyableUDT() : c('A') {}
NonTriviallyCopyableUDT(const NonTriviallyCopyableUDT& rhs) : c(rhs.c) {}
NonTriviallyCopyableUDT& operator=(const NonTriviallyCopyableUDT& rhs) {
c = rhs.c;
return *this;
}
char c;
};
bool AbslParseFlag(absl::string_view, NonTriviallyCopyableUDT*, std::string*) {
return true;
}
std::string AbslUnparseFlag(const NonTriviallyCopyableUDT&) { return ""; }
} // namespace
ABSL_FLAG(SmallAlignUDT, test_flag_sa_udt, {}, "help");
ABSL_FLAG(NonTriviallyCopyableUDT, test_flag_ntc_udt, {}, "help");
namespace {
TEST_F(FlagTest, TestSmallAlignUDT) {
SmallAlignUDT value = absl::GetFlag(FLAGS_test_flag_sa_udt);
EXPECT_EQ(value.c, 'A');
EXPECT_EQ(value.s, 12);
value.c = 'B';
value.s = 45;
absl::SetFlag(&FLAGS_test_flag_sa_udt, value);
value = absl::GetFlag(FLAGS_test_flag_sa_udt);
EXPECT_EQ(value.c, 'B');
EXPECT_EQ(value.s, 45);
}
TEST_F(FlagTest, TestNonTriviallyCopyableUDT) {
NonTriviallyCopyableUDT value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
EXPECT_EQ(value.c, 'A');
value.c = 'B';
absl::SetFlag(&FLAGS_test_flag_ntc_udt, value);
value = absl::GetFlag(FLAGS_test_flag_ntc_udt);
EXPECT_EQ(value.c, 'B');
}
} // namespace
// --------------------------------------------------------------------
namespace {
enum TestE { A = 1, B = 2, C = 3 };
struct EnumWrapper {
EnumWrapper() : e(A) {}
TestE e;
};
bool AbslParseFlag(absl::string_view, EnumWrapper*, std::string*) {
return true;
}
std::string AbslUnparseFlag(const EnumWrapper&) { return ""; }
} // namespace
ABSL_FLAG(EnumWrapper, test_enum_wrapper_flag, {}, "help");
TEST_F(FlagTest, TesTypeWrappingEnum) {
EnumWrapper value = absl::GetFlag(FLAGS_test_enum_wrapper_flag);
EXPECT_EQ(value.e, A);
value.e = B;
absl::SetFlag(&FLAGS_test_enum_wrapper_flag, value);
value = absl::GetFlag(FLAGS_test_enum_wrapper_flag);
EXPECT_EQ(value.e, B);
}