[go: nahoru, domu]

blob: 7ef7d0a77cf21773e29bde740343473960b3c438 [file] [log] [blame]
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "base/traits_bag.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace base {
namespace trait_helpers {
namespace {
struct ExampleTrait {};
struct ExampleTrait2 {};
enum class EnumTraitA { A, B, C };
enum class EnumTraitB { ONE, TWO };
struct TestTraits {
// List of traits that are valid inputs for the constructor below.
struct ValidTrait {
ValidTrait(ExampleTrait);
ValidTrait(EnumTraitA);
ValidTrait(EnumTraitB);
};
template <class... ArgTypes,
class CheckArgumentsAreValid = std::enable_if_t<
trait_helpers::AreValidTraits<ValidTrait, ArgTypes...>::value>>
constexpr TestTraits(ArgTypes... args)
: has_example_trait(trait_helpers::HasTrait<ExampleTrait>(args...)),
enum_trait_a(
trait_helpers::GetEnum<EnumTraitA, EnumTraitA::A>(args...)),
enum_trait_b(
trait_helpers::GetEnum<EnumTraitB, EnumTraitB::ONE>(args...)) {}
const bool has_example_trait;
const EnumTraitA enum_trait_a;
const EnumTraitB enum_trait_b;
};
// Like TestTraits, except ExampleTrait is filtered away.
struct FilteredTestTraits : public TestTraits {
template <class... ArgTypes,
class CheckArgumentsAreValid = std::enable_if_t<
trait_helpers::AreValidTraits<ValidTrait, ArgTypes...>::value>>
constexpr FilteredTestTraits(ArgTypes... args)
: TestTraits(Exclude<ExampleTrait>::Filter(args)...) {}
};
struct RequiredEnumTestTraits {
// List of traits that are required inputs for the constructor below.
struct ValidTrait {
ValidTrait(EnumTraitA);
};
// We require EnumTraitA to be specified.
template <class... ArgTypes,
class CheckArgumentsAreValid = std::enable_if_t<
trait_helpers::AreValidTraits<ValidTrait, ArgTypes...>::value>>
constexpr RequiredEnumTestTraits(ArgTypes... args)
: enum_trait_a(trait_helpers::GetEnum<EnumTraitA>(args...)) {}
const EnumTraitA enum_trait_a;
};
struct OptionalEnumTestTraits {
// List of traits that are optional inputs for the constructor below.
struct ValidTrait {
ValidTrait(EnumTraitA);
};
// EnumTraitA can optionally be specified.
template <class... ArgTypes,
class CheckArgumentsAreValid = std::enable_if_t<
trait_helpers::AreValidTraits<ValidTrait, ArgTypes...>::value>>
constexpr OptionalEnumTestTraits(ArgTypes... args)
: enum_trait_a(trait_helpers::GetOptionalEnum<EnumTraitA>(args...)) {}
const Optional<EnumTraitA> enum_trait_a;
};
} // namespace
TEST(TraitsBagTest, DefaultConstructor) {
constexpr TestTraits trait_test_class;
EXPECT_FALSE(trait_test_class.has_example_trait);
}
TEST(TraitsBagTest, HasTrait) {
constexpr TestTraits with_trait(ExampleTrait{});
constexpr TestTraits without_trait;
EXPECT_TRUE(with_trait.has_example_trait);
EXPECT_FALSE(without_trait.has_example_trait);
}
TEST(TraitsBagTest, GetEnumWithDefault) {
constexpr TestTraits defaults;
EXPECT_EQ(defaults.enum_trait_a, EnumTraitA::A);
EXPECT_EQ(defaults.enum_trait_b, EnumTraitB::ONE);
constexpr TestTraits a(EnumTraitA::A);
constexpr TestTraits b(EnumTraitA::B);
constexpr TestTraits c(EnumTraitA::C);
EXPECT_EQ(a.enum_trait_a, EnumTraitA::A);
EXPECT_EQ(a.enum_trait_b, EnumTraitB::ONE);
EXPECT_EQ(b.enum_trait_a, EnumTraitA::B);
EXPECT_EQ(b.enum_trait_b, EnumTraitB::ONE);
EXPECT_EQ(c.enum_trait_a, EnumTraitA::C);
EXPECT_EQ(c.enum_trait_b, EnumTraitB::ONE);
constexpr TestTraits a_one(EnumTraitA::A, EnumTraitB::ONE);
constexpr TestTraits b_one(EnumTraitA::B, EnumTraitB::ONE);
constexpr TestTraits c_one(EnumTraitA::C, EnumTraitB::ONE);
EXPECT_EQ(a_one.enum_trait_a, EnumTraitA::A);
EXPECT_EQ(a_one.enum_trait_b, EnumTraitB::ONE);
EXPECT_EQ(b_one.enum_trait_a, EnumTraitA::B);
EXPECT_EQ(b_one.enum_trait_b, EnumTraitB::ONE);
EXPECT_EQ(c_one.enum_trait_a, EnumTraitA::C);
EXPECT_EQ(c_one.enum_trait_b, EnumTraitB::ONE);
constexpr TestTraits a_two(EnumTraitA::A, EnumTraitB::TWO);
constexpr TestTraits b_two(EnumTraitA::B, EnumTraitB::TWO);
constexpr TestTraits c_two(EnumTraitA::C, EnumTraitB::TWO);
EXPECT_EQ(a_two.enum_trait_a, EnumTraitA::A);
EXPECT_EQ(a_two.enum_trait_b, EnumTraitB::TWO);
EXPECT_EQ(b_two.enum_trait_a, EnumTraitA::B);
EXPECT_EQ(b_two.enum_trait_b, EnumTraitB::TWO);
EXPECT_EQ(c_two.enum_trait_a, EnumTraitA::C);
EXPECT_EQ(c_two.enum_trait_b, EnumTraitB::TWO);
}
TEST(TraitsBagTest, RequiredEnum) {
constexpr RequiredEnumTestTraits a(EnumTraitA::A);
constexpr RequiredEnumTestTraits b(EnumTraitA::B);
constexpr RequiredEnumTestTraits c(EnumTraitA::C);
EXPECT_EQ(a.enum_trait_a, EnumTraitA::A);
EXPECT_EQ(b.enum_trait_a, EnumTraitA::B);
EXPECT_EQ(c.enum_trait_a, EnumTraitA::C);
}
TEST(TraitsBagTest, OptionalEnum) {
constexpr OptionalEnumTestTraits not_set;
constexpr OptionalEnumTestTraits set(EnumTraitA::B);
EXPECT_FALSE(not_set.enum_trait_a.has_value());
ASSERT_TRUE(set.enum_trait_a.has_value());
EXPECT_EQ(*set.enum_trait_a, EnumTraitA::B);
}
TEST(TraitsBagTest, ValidTraitInheritance) {
struct ValidTraitsA {
ValidTraitsA(EnumTraitA);
};
struct ValidTraitsB {
ValidTraitsB(ValidTraitsA);
ValidTraitsB(EnumTraitB);
};
static_assert(AreValidTraits<ValidTraitsA, EnumTraitA>(), "");
static_assert(AreValidTraits<ValidTraitsB, EnumTraitA, EnumTraitB>(), "");
}
TEST(TraitsBagTest, Filtering) {
using Predicate = Exclude<ExampleTrait, EnumTraitA>;
static_assert(
std::is_same<ExampleTrait2,
decltype(Predicate::Filter(ExampleTrait2{}))>::value,
"ExampleTrait2 should not be filtered");
static_assert(
std::is_same<EmptyTrait,
decltype(Predicate::Filter(ExampleTrait{}))>::value,
"ExampleTrait should be filtered");
static_assert(std::is_same<EmptyTrait,
decltype(Predicate::Filter(EnumTraitA::A))>::value,
"EnumTraitA should be filtered");
static_assert(
std::is_same<EnumTraitB,
decltype(Predicate::Filter(EnumTraitB::TWO))>::value,
"EnumTraitB should not be filtered");
static_assert(std::is_same<EmptyTrait,
decltype(Predicate::Filter(EmptyTrait{}))>::value,
"EmptyTrait should not be filtered");
}
TEST(TraitsBagTest, FilteredTestTraits) {
FilteredTestTraits filtered(ExampleTrait(), EnumTraitA::C, EnumTraitB::TWO);
// ExampleTrait should have been filtered away.
EXPECT_FALSE(filtered.has_example_trait);
// The other traits should have been set however.
EXPECT_EQ(filtered.enum_trait_a, EnumTraitA::C);
EXPECT_EQ(filtered.enum_trait_b, EnumTraitB::TWO);
}
TEST(TraitsBagTest, EmptyTraitIsValid) {
static_assert(IsValidTrait<TestTraits::ValidTrait, EmptyTrait>(), "");
}
} // namespace trait_helpers
} // namespace base