| #include <sdbusplus/utility/dedup_variant.hpp> |
| #include <sdbusplus/utility/merge_variants.hpp> |
| #include <sdbusplus/utility/type_traits.hpp> |
| |
| #include <type_traits> |
| |
| #include <gmock/gmock.h> |
| |
| namespace |
| { |
| |
| using sdbusplus::utility::array_to_ptr_t; |
| using std::is_same_v; |
| |
| TEST(TypeTraits, Basic) |
| { |
| static_assert(is_same_v<char, array_to_ptr_t<char, char>>, |
| "array_to_ptr_t<char, char> != char"); |
| |
| static_assert(is_same_v<char*, array_to_ptr_t<char, char*>>, |
| "array_to_ptr_t<char, char*> != char*"); |
| |
| static_assert(is_same_v<char*, array_to_ptr_t<char, char[100]>>, |
| "array_to_ptr_t<char, char[100]> != char*"); |
| |
| static_assert(is_same_v<char[100], array_to_ptr_t<int, char[100]>>, |
| "array_to_ptr_t<int, char[100]> != char[100]"); |
| } |
| |
| TEST(TypeTraits, HasMemberFind) |
| { |
| using sdbusplus::utility::has_member_find_v; |
| using namespace testing; |
| |
| ASSERT_THAT((has_member_find_v<std::map<std::string, int>>), Eq(true)); |
| ASSERT_THAT((has_member_find_v<std::vector<std::pair<std::string, int>>>), |
| Eq(false)); |
| |
| struct Foo |
| { |
| using value_type = std::pair<int, int>; |
| |
| void find(std::tuple_element_t<0, value_type>) {} |
| }; |
| |
| struct Bar |
| {}; |
| |
| ASSERT_THAT(has_member_find_v<Foo>, Eq(true)); |
| ASSERT_THAT(has_member_find_v<Foo&>, Eq(true)); |
| ASSERT_THAT(has_member_find_v<const Foo&>, Eq(true)); |
| |
| ASSERT_THAT(has_member_find_v<Bar>, Eq(false)); |
| } |
| |
| TEST(TypeTraits, HasMemberContains) |
| { |
| using sdbusplus::utility::has_member_contains_v; |
| using namespace testing; |
| |
| // std::map has member_contains from c++20 |
| ASSERT_THAT((has_member_contains_v<std::map<std::string, int>>), Eq(true)); |
| ASSERT_THAT( |
| (has_member_contains_v<std::vector<std::pair<std::string, int>>>), |
| Eq(false)); |
| |
| struct Foo |
| { |
| using value_type = std::pair<int, int>; |
| |
| void contains(std::tuple_element_t<0, value_type>) {} |
| }; |
| |
| struct Bar |
| {}; |
| |
| ASSERT_THAT(has_member_contains_v<Foo>, Eq(true)); |
| ASSERT_THAT(has_member_contains_v<Foo&>, Eq(true)); |
| ASSERT_THAT(has_member_contains_v<const Foo&>, Eq(true)); |
| |
| ASSERT_THAT(has_member_contains_v<Bar>, Eq(false)); |
| } |
| |
| TEST(TypeTraits, IsOptional) |
| { |
| using sdbusplus::utility::is_optional; |
| using sdbusplus::utility::is_optional_v; |
| |
| ASSERT_TRUE(is_optional<std::optional<int>>::value); |
| ASSERT_TRUE(is_optional<std::optional<int>&>::value); |
| ASSERT_FALSE(is_optional<int>::value); |
| |
| ASSERT_TRUE(is_optional_v<std::optional<int>>); |
| ASSERT_TRUE(is_optional_v<std::optional<int>&>); |
| ASSERT_FALSE(is_optional_v<int>); |
| } |
| |
| // Tests for dedup_variant. |
| static_assert(std::is_same_v<std::variant<size_t>, |
| sdbusplus::utility::dedup_variant_t<size_t>>); |
| static_assert( |
| std::is_same_v<std::variant<char, size_t>, |
| sdbusplus::utility::dedup_variant_t<char, size_t>>); |
| static_assert(std::is_same_v< |
| std::variant<uint32_t, uint64_t>, |
| sdbusplus::utility::dedup_variant_t<uint32_t, uint64_t, size_t>>); |
| |
| // Tests for merge_variants. |
| static_assert( |
| std::is_same_v<std::variant<size_t>, |
| sdbusplus::utility::merge_variants_t<std::variant<size_t>>>); |
| static_assert(std::is_same_v<std::variant<char, uint32_t, uint64_t>, |
| sdbusplus::utility::merge_variants_t< |
| std::variant<char, uint32_t>, |
| std::variant<uint32_t, uint64_t, size_t>>>); |
| |
| } // namespace |