1//===----------------------------------------------------------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9// UNSUPPORTED: c++03, c++11, c++14
10
11// <variant>
12
13// template <class... Types> struct hash<variant<Types...>>;
14// template <> struct hash<monostate>;
15
16#include <cassert>
17#include <type_traits>
18#include <variant>
19
20#include "test_macros.h"
21#include "variant_test_helpers.h"
22#include "poisoned_hash_helper.h"
23
24#ifndef TEST_HAS_NO_EXCEPTIONS
25template <>
26struct std::hash<::MakeEmptyT> {
27 std::size_t operator()(const ::MakeEmptyT &) const {
28 assert(false);
29 return 0;
30 }
31};
32#endif
33
34void test_hash_variant() {
35 {
36 using V = std::variant<int, long, int>;
37 using H = std::hash<V>;
38 const V v(std::in_place_index<0>, 42);
39 const V v_copy = v;
40 V v2(std::in_place_index<0>, 100);
41 const H h{};
42 assert(h(v) == h(v));
43 assert(h(v) != h(v2));
44 assert(h(v) == h(v_copy));
45 {
46 ASSERT_SAME_TYPE(decltype(h(v)), std::size_t);
47 static_assert(std::is_copy_constructible<H>::value, "");
48 }
49 }
50 {
51 using V = std::variant<std::monostate, int, long, const char *>;
52 using H = std::hash<V>;
53 const char *str = "hello";
54 const V v0;
55 const V v0_other;
56 const V v1(42);
57 const V v1_other(100);
58 V v2(100l);
59 V v2_other(999l);
60 V v3(str);
61 V v3_other("not hello");
62 const H h{};
63 assert(h(v0) == h(v0));
64 assert(h(v0) == h(v0_other));
65 assert(h(v1) == h(v1));
66 assert(h(v1) != h(v1_other));
67 assert(h(v2) == h(v2));
68 assert(h(v2) != h(v2_other));
69 assert(h(v3) == h(v3));
70 assert(h(v3) != h(v3_other));
71 assert(h(v0) != h(v1));
72 assert(h(v0) != h(v2));
73 assert(h(v0) != h(v3));
74 assert(h(v1) != h(v2));
75 assert(h(v1) != h(v3));
76 assert(h(v2) != h(v3));
77 }
78#ifndef TEST_HAS_NO_EXCEPTIONS
79 {
80 using V = std::variant<int, MakeEmptyT>;
81 using H = std::hash<V>;
82 V v;
83 makeEmpty(v);
84 V v2;
85 makeEmpty(v2);
86 const H h{};
87 assert(h(v) == h(v2));
88 }
89#endif
90}
91
92void test_hash_monostate() {
93 using H = std::hash<std::monostate>;
94 const H h{};
95 std::monostate m1{};
96 const std::monostate m2{};
97 assert(h(m1) == h(m1));
98 assert(h(m2) == h(m2));
99 assert(h(m1) == h(m2));
100 {
101 ASSERT_SAME_TYPE(decltype(h(m1)), std::size_t);
102 ASSERT_NOEXCEPT(h(m1));
103 static_assert(std::is_copy_constructible<H>::value, "");
104 }
105 {
106 test_hash_enabled<std::monostate>();
107 }
108}
109
110void test_hash_variant_duplicate_elements() {
111 // Test that the index of the alternative participates in the hash value.
112 using V = std::variant<std::monostate, std::monostate>;
113 using H = std::hash<V>;
114 H h{};
115 const V v1(std::in_place_index<0>);
116 const V v2(std::in_place_index<1>);
117 assert(h(v1) == h(v1));
118 assert(h(v2) == h(v2));
119 LIBCPP_ASSERT(h(v1) != h(v2));
120}
121
122struct A {};
123struct B {};
124
125template <>
126struct std::hash<B> {
127 std::size_t operator()(B const&) const {
128 return 0;
129 }
130};
131
132void test_hash_variant_enabled() {
133 {
134 test_hash_enabled<std::variant<int> >();
135 test_hash_enabled<std::variant<int*, long, double, const int> >();
136 }
137 {
138 test_hash_disabled<std::variant<int, A>>();
139 test_hash_disabled<std::variant<const A, void*>>();
140 }
141 {
142 test_hash_enabled<std::variant<int, B>>();
143 test_hash_enabled<std::variant<const B, int>>();
144 }
145}
146
147int main(int, char**) {
148 test_hash_variant();
149 test_hash_variant_duplicate_elements();
150 test_hash_monostate();
151 test_hash_variant_enabled();
152
153 return 0;
154}
155

source code of libcxx/test/std/utilities/variant/variant.hash/hash.pass.cpp