├── .gitattributes
├── .gitignore
├── CMakeLists.txt
├── LICENSE
├── README.md
├── benchmarks
    └── benchmark.cpp
├── include
    └── swl
    │   ├── variant.hpp
    │   ├── variant_detail.hpp
    │   └── variant_visit.hpp
└── tests
    ├── archetypes.h
    ├── archetypes.ipp
    ├── poisoned_hash_helper.h
    ├── swl_assert.hpp
    ├── test_convertible.h
    ├── test_macros.h
    ├── test_workarounds.h
    ├── tests
        ├── throwing_conversion.pass.cpp
        ├── variant.bad_variant_access
        │   └── bad_variant_access.pass.cpp
        ├── variant.get
        │   ├── get_if_index.pass.cpp
        │   ├── get_if_type.pass.cpp
        │   ├── get_index.pass.cpp
        │   ├── get_type.pass.cpp
        │   └── holds_alternative.pass.cpp
        ├── variant.hash
        │   ├── enabled_hash.pass.cpp.ignore
        │   └── hash.pass.cpp
        ├── variant.helpers
        │   ├── variant_alternative.fail.cpp
        │   ├── variant_alternative.pass.cpp
        │   └── variant_size.pass.cpp
        ├── variant.monostate.relops
        │   └── relops.pass.cpp
        ├── variant.monostate
        │   └── monostate.pass.cpp
        ├── variant.relops
        │   ├── relops.pass.cpp
        │   └── relops_bool_conv.fail.cpp
        ├── variant.variant
        │   ├── variant.assign
        │   │   ├── T.pass.cpp
        │   │   ├── conv.pass.cpp
        │   │   ├── copy.fail.cpp
        │   │   ├── copy.pass.cpp
        │   │   └── move.pass.cpp
        │   ├── variant.ctor
        │   │   ├── T.pass.cpp
        │   │   ├── conv.pass.cpp
        │   │   ├── copy.pass.cpp
        │   │   ├── default.pass.cpp
        │   │   ├── in_place_index_args.pass.cpp
        │   │   ├── in_place_index_init_list_args.pass.cpp
        │   │   ├── in_place_type_args.pass.cpp
        │   │   ├── in_place_type_init_list_args.pass.cpp
        │   │   └── move.pass.cpp
        │   ├── variant.dtor
        │   │   └── dtor.pass.cpp
        │   ├── variant.mod
        │   │   ├── emplace_index_args.pass.cpp
        │   │   ├── emplace_index_init_list_args.pass.cpp
        │   │   ├── emplace_type_args.pass.cpp
        │   │   └── emplace_type_init_list_args.pass.cpp
        │   ├── variant.status
        │   │   ├── index.pass.cpp
        │   │   └── valueless_by_exception.pass.cpp
        │   ├── variant.swap
        │   │   └── swap.pass.cpp
        │   ├── variant_array.fail.cpp
        │   ├── variant_empty.fail.cpp
        │   ├── variant_reference.fail.cpp
        │   └── variant_void.fail.cpp
        └── variant.visit
        │   ├── robust_against_adl.pass.cpp
        │   ├── visit.pass.cpp
        │   └── visit_return_type.pass.cpp
    ├── type_id.h
    └── variant_test_helpers.h


/.gitattributes:
--------------------------------------------------------------------------------
1 | # Auto detect text files and perform LF normalization
2 | * text=auto
3 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | 
2 | 


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.20)
 2 | 
 3 | project(swl.variant
 4 | 	VERSION 1.0.0 
 5 | 	LANGUAGES CXX
 6 | 	HOMEPAGE_URL https://github.com/groundswellaudio/swl-variant)
 7 | 
 8 | add_library(swl-variant INTERFACE)
 9 | 
10 | target_include_directories(swl-variant INTERFACE
11 |   $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
12 |   $<INSTALL_INTERFACE:./include>)
13 | 
14 | target_compile_features(swl-variant INTERFACE cxx_std_20)
15 | 
16 | if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
17 | 	
18 | 	include(CTest)
19 | 	
20 | 	## tests that are supposed to not compile
21 | 	## https://stackoverflow.com/questions/30155619/expected-build-failure-tests-in-cmake
22 | 	
23 | 	math(EXPR test_idx 0)
24 | 	
25 | 	file(GLOB_RECURSE test-sources CONFIGURE_DEPENDS tests/*.fail.cpp)
26 | 	foreach (source IN LISTS test-sources)
27 | 		get_filename_component(name "${source}" NAME_WE)
28 |   		
29 |   		set(test "${PROJECT_NAME}-test-${name}-${test_idx}")
30 |   		MATH(EXPR test_idx "${test_idx} + 1")
31 |   		
32 |   		add_executable(${test} "${source}")
33 |   		
34 |   		## avoid actually building the target
35 |   		set_target_properties(${test} PROPERTIES
36 |                       EXCLUDE_FROM_ALL TRUE
37 |                       EXCLUDE_FROM_DEFAULT_BUILD TRUE)
38 |         
39 | 		target_link_libraries(${test} swl-variant)
40 | 		target_include_directories(${test} PRIVATE ./tests)
41 | 		
42 | 		add_test(NAME ${test}
43 |          COMMAND ${CMAKE_COMMAND} --build ./ --target ${test} --config $<CONFIGURATION>
44 |          WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
45 |         
46 |         set_tests_properties(${test} PROPERTIES WILL_FAIL TRUE)
47 |         
48 | 	endforeach()
49 | 	
50 | 	file(GLOB_RECURSE test-sources CONFIGURE_DEPENDS tests/*.pass.cpp)
51 | 
52 | 	foreach (source IN LISTS test-sources)
53 | 		get_filename_component(name "${source}" NAME_WE)
54 |   		
55 |   		set(test "${PROJECT_NAME}-test-${name}-${test_idx}")
56 |   		MATH(EXPR test_idx "${test_idx} + 1")
57 |   		
58 | 		add_executable(${test} "${source}")
59 | 		target_link_libraries(${test} swl-variant)
60 | 		target_include_directories(${test} PRIVATE ./tests)
61 | 		add_test(NAME ${test} COMMAND ${test})
62 | 	endforeach()
63 | 	
64 | endif()


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2021 Jean-Baptiste Vallon Hoarau
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # swl::variant
 2 | 
 3 | A minimal compile-time overhead, C++20 implementation of std::variant. Fully standard conforming with a couple of documented differences. 
 4 | 
 5 | ## Compile-time performance
 6 | 
 7 | Because `std::variant` is implemented in both GCC and Clang libraries using a simple recursive union, accessing each members result in approximately N^2 functions template instantiations for a variant of size N. This implementation instead use a "binary-tree of unions", resulting in N.log2(N) instantiations, which results in faster compile times (see measurements below). 
 8 | 
 9 | ## Run-time performance and binary size
10 | 
11 | `std::variant` visit method is usually implemented using a table of functions pointers. Unfortunately, compilers cannot (yet?) "see through" those, and the generated code tends to be much larger and slower than a switch-case equivalent - [more on this here](https://mpark.github.io/programming/2019/01/22/variant-visitation-v2/). Similarly to [Michael Park's implementation](https://github.com/mpark/variant), this implementation use a big, recursive switch for visitation. 
12 | 
13 | ## Testing
14 | 
15 | The tests are from the LLVM test suite.
16 | To run them do : 
17 | `mkdir ./test_out && cd ./test_out`
18 | `cmake ../`
19 | `ctest --build-and-test ../ ./ --build-generator "Unix Makefiles"` (replace "Unix Makefiles" as needed)
20 | `make test`
21 | 
22 | ## Implementation divergence
23 | 
24 | * `index()` doesn't return a `std::size_t`, but an integer whose size depends on the numbers of type inside the variant. Basically either `unsigned char` or `unsigned short`. 
25 | * a `visit_with_index` function is furnished, which is useful for example when you want 
26 |   to apply a function to multiple variant whose index is known to be the same : 
27 |   ```cpp
28 |   visit_with_index(variant1, [&variant2] (auto& elem, auto cst) { foo(elem, get<cst>(variant2)); });
29 |   ```
30 | 
31 | ## Extensions and customization 
32 | 
33 | * If you like to live dangerously, `swl::unsafe_get` behave just like get, but without any errors checking. 
34 | 
35 | * Two macro based knobs are available : 
36 | 	- `SWL_VARIANT_NO_STD_HASH` : this disable the `std::hash` specializations and avoid the `#include <functional>`, which is big
37 | 	- `SWL_VARIANT_NO_CONSTEXPR_EMPLACE` : this disable `constexpr` for emplace, and avoid the `#include <memory>`, which is even bigger. Note that this one is an ODR footgun : don't use it if you can't guarantee that it's enabled everywhere in your binaries. 
38 | 
39 | 	To use these macros, define them in a file named `swl_variant_knobs.hpp`, and put it either in the same directory as `variant.hpp` or at the root of a header search path. 
40 | 
41 | 	Both of these are provided to reduce compile times, whether or not this matter depends on your compiler : on my version of Clang, activating both of these macros result in a mere -0.5s, on GCC however, this reduce compile times by more than 4s. 
42 | 
43 | ## Measurements 
44 | 
45 | The measurements are of the form (compile time, executable file size). 
46 | 
47 | All of these measurements were done without optimizations. 
48 | 
49 | The compilers used were Clang 12 and GCC 10. 
50 | 
51 | Single visitation : 
52 | | Variant size | swl (clang) | std (clang) | swl (gcc) | std (gcc) 
53 | |--|--|--|--|--|
54 | | 20  | 1s, 50 Ko        | 1.2s, 80 Ko   | 4.6s, 50 Ko  | 1s, 133 Ko   |
55 | | 40  | 1.2s, 120 Ko     | 2s, 260 Ko    | 4.8s, 120 Ko | 2s, 440 Ko   |
56 | | 80  | 1.4s, 300 Ko     | 4.6s, 1 Mo    | 5.3s, 290 Ko | 5.7s, 1.8 Mo |
57 | | 160 | 1.8s, 700 Ko     | 15s, 4.3 Mo   | 6s, 720 Ko   | 21s, 8.2 Mo  |
58 | | 320 | 3s, 1.7 Mo       | 54s, 22 Mo    | 8.4s, 1.8 Mo | 90s, 40 Mo   |
59 | | 640 | 5s, 4 Mo         | 250s, 130 Mo  | 17s, 4.4 Mo  | 415s, 250 Mo |
60 | 
61 | Multi visitation of some variants of size 10 : 
62 | 
63 | | Numbers of variants | swl (clang) | std (clang) | swl (gcc) | std (gcc) 
64 | |--|--|--|--|--|
65 | | 2 | 1.1s, 49 Ko   | 1.6s, 128 Ko   | 2.8s, 41 Ko    | 1.3s, 160 Ko  |
66 | | 3 | 2s, 142 Ko    | 8s, 1.1 Mo     | 3.8s, 123 Ko   | 9s, 1.5 Mo    |
67 | | 4 | 6.7s, 630 Ko  | 68s, 11 Mo     | 10.5s, 560 Ko  | 95s, 17 Mo    |
68 | 
69 | ### Tested compilers
70 | 
71 | * GCC 10
72 | 
73 | Clang 12/13 will only work for trivially destructible types as their implementation of C++20 is incomplete. 
74 | 


--------------------------------------------------------------------------------
/benchmarks/benchmark.cpp:
--------------------------------------------------------------------------------
 1 |  
 2 | //#define TEST_STD
 3 | 
 4 | #ifdef TEST_STD
 5 | 	#include <variant>
 6 | 	#define swl std
 7 | #else
 8 | 	#include <swl/variant.hpp>
 9 | #endif
10 | 
11 | #define PACK int, float, char, bool, double
12 | #define PACK10 PACK, PACK 
13 | #define PACK20 PACK10, PACK10
14 | #define PACK40 PACK20, PACK20 
15 | #define PACK80 PACK40, PACK40
16 | #define PACK160 PACK80, PACK80
17 | #define PACK320 PACK160, PACK160
18 | #define PACK640 PACK320, PACK320
19 | 
20 | //#define TEST_MULTI_VISIT
21 | 
22 | int main(){
23 | 	
24 | 	swl::variant<PACK160> a, b, c, d;
25 | 	
26 | 	#ifndef TEST_MULTI_VISIT
27 | 	
28 | 		swl::visit( [] (auto x) {}, a );
29 | 	
30 | 	#else
31 | 		
32 | 		swl::visit( [] (auto... args) {}, a, b, c );
33 | 		
34 | 	#endif
35 | }


--------------------------------------------------------------------------------
/include/swl/variant_detail.hpp:
--------------------------------------------------------------------------------
  1 | #ifdef SWL_CPP_LIBRARY_VARIANT_HPP
  2 | 
  3 | template <int N>
  4 | constexpr int find_first_true(bool (&&arr)[N]){
  5 | 	for (int k = 0; k < N; ++k)
  6 | 		if (arr[k]) 
  7 | 			return k;
  8 | 	return -1;
  9 | }
 10 | 
 11 | template <class T, class... Ts>
 12 | inline constexpr bool appears_exactly_once = (static_cast<unsigned short>(std::is_same_v<T, Ts>) + ...) == 1;
 13 | 
 14 | // ============= type pack element 
 15 | 
 16 | #if __has_builtin(__type_pack_element)
 17 | 
 18 | template <std::size_t K, class... Ts>
 19 | using type_pack_element = __type_pack_element<K, Ts...>;
 20 | 
 21 | #else
 22 | 
 23 | template <unsigned char = 1>
 24 | struct find_type_i;
 25 | 
 26 | template <>
 27 | struct find_type_i<1> {
 28 | 	template <std::size_t Idx, class T, class... Ts>
 29 | 	using f = typename find_type_i<(Idx != 1)>::template f<Idx - 1, Ts...>;
 30 | };
 31 | 
 32 | template <>
 33 | struct find_type_i<0> {
 34 | 	template <std::size_t, class T, class... Ts>
 35 | 	using f = T;
 36 | };
 37 | 
 38 | template <std::size_t K, class... Ts>
 39 | using type_pack_element = typename find_type_i<(K != 0)>::template f<K, Ts...>;
 40 | 
 41 | #endif
 42 | 
 43 | // ============= overload match detector. to be used for variant generic assignment
 44 | 
 45 | template <class T>
 46 | using arr1 = T[1];
 47 | 
 48 | template <std::size_t N, class A>
 49 | struct overload_frag {
 50 | 	using type = A;
 51 | 	template <class T>
 52 | 		requires requires { arr1<A>{std::declval<T>()}; }
 53 | 	auto operator()(A, T&&) -> overload_frag<N, A>;
 54 | }; 
 55 | 
 56 | template <class Seq, class... Args>
 57 | struct make_overload;
 58 | 
 59 | template <std::size_t... Idx, class... Args>
 60 | struct make_overload<std::integer_sequence<std::size_t, Idx...>, Args...>
 61 | 	 : overload_frag<Idx, Args>... { 
 62 | 	using overload_frag<Idx, Args>::operator()...;
 63 | };
 64 | 
 65 | template <class T, class... Ts>
 66 | using best_overload_match = typename decltype( 
 67 | 	make_overload<std::make_index_sequence<sizeof...(Ts)>, Ts...>{}
 68 | 	( std::declval<T>(), std::declval<T>() )
 69 | )::type;
 70 | 	
 71 | template <class T, class... Ts>
 72 | concept has_non_ambiguous_match = 
 73 | 	requires { typename best_overload_match<T, Ts...>; };
 74 | 
 75 | // ================================== rel ops
 76 | 
 77 | template <class From, class To>
 78 | concept convertible = std::is_convertible_v<From, To>;
 79 | 
 80 | template <class T>
 81 | concept has_eq_comp = requires (T a, T b) { 
 82 | 	{ a == b } -> convertible<bool>; 
 83 | };
 84 | 
 85 | template <class T>
 86 | concept has_lesser_comp = requires (T a, T b) { 
 87 | 	{ a < b } -> convertible<bool>; 
 88 | };
 89 | 
 90 | template <class T>
 91 | concept has_less_or_eq_comp = requires (T a, T b) { 
 92 | 	{ a <= b } -> convertible<bool>;
 93 | };
 94 | 
 95 | template <class A>
 96 | struct emplace_no_dtor_from_elem {
 97 | 	template <class T>
 98 | 	constexpr void operator()(T&& elem, auto index_) const {
 99 | 		a.template emplace_no_dtor<index_>( static_cast<T&&>(elem) ); 
100 | 	}
101 | 	A& a;
102 | };
103 | 
104 | template <class E, class T>
105 | constexpr void destruct(T& obj){
106 | 	if constexpr (not std::is_trivially_destructible_v<E>)
107 | 		obj.~E();
108 | }
109 | 	
110 | // =============================== variant union types
111 | 	
112 | // =================== base variant storage type 
113 | // this type is used to build a N-ary tree of union. 
114 | 
115 | struct dummy_type{ static constexpr int elem_size = 0; }; // used to fill the back of union nodes
116 | 
117 | using union_index_t = unsigned;
118 | 
119 | #define TRAIT(trait) ( std::is_##trait##_v<A> && std::is_##trait##_v<B> )
120 | 
121 | #define SFM(signature, trait) \
122 | 	signature = default; \
123 | 	signature requires (TRAIT(trait) and not TRAIT(trivially_##trait)) {} 
124 | 
125 | // given the two members of type A and B of an union X
126 | // this create the proper conditionally trivial special members functions
127 | #define INJECT_UNION_SFM(X) \
128 | 	SFM(constexpr X (const X &), copy_constructible) \
129 | 	SFM(constexpr X (X&&), move_constructible) \
130 | 	SFM(constexpr X& operator=(const X&), copy_assignable) \
131 | 	SFM(constexpr X& operator=(X&&), move_assignable) \
132 | 	SFM(constexpr ~X(), destructible)
133 | 
134 | template <bool IsLeaf>
135 | struct node_trait;
136 | 
137 | template <>
138 | struct node_trait<true> {
139 | 
140 | 	template <class A, class B>
141 | 	static constexpr auto elem_size = not( std::is_same_v<B, dummy_type> ) ? 2 : 1;
142 | 	
143 | 	template <std::size_t, class>
144 | 	static constexpr char ctor_branch = 0;
145 | };
146 | 
147 | template <>
148 | struct node_trait<false> {
149 | 	template <class A, class B>
150 | 	static constexpr auto elem_size = A::elem_size + B::elem_size;
151 | 	
152 | 	template <std::size_t Index, class A>
153 | 	static constexpr char ctor_branch = (Index < A::elem_size) ? 1 : 2;
154 | };
155 | 
156 | template <bool IsLeaf, class A, class B>
157 | struct union_node {
158 | 
159 | 	union {
160 | 		A a; 
161 | 		B b;
162 | 	};
163 | 	
164 | 	static constexpr auto elem_size = node_trait<IsLeaf>::template elem_size<A, B>;
165 | 	
166 | 	constexpr union_node() = default;
167 | 	
168 | 	template <std::size_t Index, class... Args>
169 | 		requires (node_trait<IsLeaf>::template ctor_branch<Index, A> == 1)
170 | 	constexpr union_node(in_place_index_t<Index>, Args&&... args)
171 | 	: a{ in_place_index<Index>, static_cast<Args&&>(args)... } 
172 | 	{}
173 | 	
174 | 	template <std::size_t Index, class... Args>
175 | 		requires (node_trait<IsLeaf>::template ctor_branch<Index, A> == 2)
176 | 	constexpr union_node(in_place_index_t<Index>, Args&&... args)
177 | 	: b{ in_place_index<Index - A::elem_size>, static_cast<Args&&>(args)... } 
178 | 	{}
179 | 	
180 | 	template <class... Args>
181 | 		requires (IsLeaf)
182 | 	constexpr union_node(in_place_index_t<0>, Args&&... args)
183 | 	: a{static_cast<Args&&>(args)...} 
184 | 	{}
185 | 	
186 | 	template <class... Args>
187 | 		requires (IsLeaf)
188 | 	constexpr union_node(in_place_index_t<1>, Args&&... args)
189 | 	: b{static_cast<Args&&>(args)...} 
190 | 	{}
191 | 	
192 | 	constexpr union_node(dummy_type)
193 | 		requires (std::is_same_v<dummy_type, B>)
194 | 	: b{}
195 | 	{}
196 | 	
197 | 	template <union_index_t Index>
198 | 	constexpr auto& get()
199 | 	{
200 | 		if constexpr (IsLeaf)
201 | 		{
202 | 			if constexpr ( Index == 0 )
203 | 				return a;
204 | 			else 
205 | 				return b;
206 | 		}
207 | 		else 
208 | 		{
209 | 			if constexpr ( Index < A::elem_size )
210 | 				return a.template get<Index>();
211 | 			else 
212 | 				return b.template get<Index - A::elem_size>();	
213 | 		}
214 | 	}
215 | 	
216 | 	INJECT_UNION_SFM(union_node)
217 | };
218 | 
219 | #undef INJECT_UNION_SFM
220 | #undef SFM
221 | #undef TRAIT
222 | 
223 | // =================== algorithm to build the tree of unions 
224 | // take a sequence of types and perform an order preserving fold until only one type is left
225 | // the first parameter is the numbers of types remaining for the current pass
226 | 
227 | constexpr unsigned char pick_next(unsigned remaining){
228 | 	return remaining >= 2 ? 2 : remaining;
229 | }
230 | 
231 | template <unsigned char Pick, unsigned char GoOn, bool FirstPass>
232 | struct make_tree;
233 | 
234 | template <bool IsFirstPass>
235 | struct make_tree<2, 1, IsFirstPass> {
236 | 	template <unsigned Remaining, class A, class B, class... Ts>
237 | 	using f = typename make_tree
238 | 	<
239 | 	 pick_next(Remaining - 2), 
240 | 	 sizeof...(Ts) != 0,
241 | 	 IsFirstPass
242 | 	>
243 | 	::template f
244 | 	<
245 | 	 Remaining - 2, 
246 | 	 Ts..., 
247 | 	 union_node<IsFirstPass, A, B>
248 | 	>; 
249 | };
250 | 
251 | // only one type left, stop
252 | template <bool F>
253 | struct make_tree<0, 0, F> {
254 | 	template <unsigned, class A>
255 | 	using f = A;
256 | };
257 | 
258 | // end of one pass, restart
259 | template <bool IsFirstPass>
260 | struct make_tree<0, 1, IsFirstPass> {
261 | 	template <unsigned Remaining, class... Ts>
262 | 	using f = typename make_tree
263 | 	<
264 | 	 pick_next(sizeof...(Ts)), 
265 | 	 (sizeof...(Ts) != 1), 
266 | 	 false  // <- both first pass and tail call recurse into a tail call
267 | 	>
268 | 	::template f<sizeof...(Ts), Ts...>;
269 | };
270 | 
271 | // one odd type left in the pass, put it at the back to preserve the order
272 | template <>
273 | struct make_tree<1, 1, false> {
274 | 	template <unsigned Remaining, class A, class... Ts>
275 | 	using f = typename make_tree<0, sizeof...(Ts) != 0, false>
276 | 		::template f<0, Ts..., A>;
277 | };
278 | 
279 | // one odd type left in the first pass, wrap it in an union
280 | template <>
281 | struct make_tree<1, 1, true> {
282 | 	template <unsigned, class A, class... Ts>
283 | 	using f = typename make_tree<0, sizeof...(Ts) != 0, false>
284 | 		::template f<0, Ts..., union_node<true, A, dummy_type>>;
285 | };
286 | 
287 | template <class... Ts>
288 | using make_tree_union = typename 
289 | 	make_tree<pick_next(sizeof...(Ts)), 1, true>::template f<sizeof...(Ts), Ts...>;
290 | 
291 | // ============================================================
292 | 
293 | // Ts... must be sorted in ascending size 
294 | template <std::size_t Num, class... Ts>
295 | using smallest_suitable_integer_type = 
296 | 	type_pack_element<(static_cast<unsigned char>(Num > std::numeric_limits<Ts>::max()) + ...),
297 | 					  Ts...
298 | 					  >;
299 | 
300 | // why do we need this again? i think something to do with GCC? 
301 | namespace swap_trait {
302 | 	using std::swap;    
303 | 	
304 | 	template <class A>
305 | 	concept able = requires (A a, A b) { swap(a, b); };
306 | 	
307 | 	template <class A>
308 | 	inline constexpr bool nothrow = noexcept( swap(std::declval<A&>(), std::declval<A&>()) );
309 | }
310 | 
311 | #ifndef SWL_VARIANT_NO_STD_HASH
312 | 	template <class T>
313 | 	inline constexpr bool has_std_hash = requires (T t) { 
314 | 		std::size_t( ::std::hash< std::remove_cvref_t<T> >{}(t) ); 
315 | 	};
316 | #endif
317 | 
318 | template <class T>
319 | inline constexpr T* addressof( T& obj ) noexcept {
320 | 	#if defined(__GNUC__) || defined( __clang__ )
321 | 		return __builtin_addressof(obj);
322 | 	#elif defined (SWL_VARIANT_NO_CONSTEXPR_EMPLACE)
323 | 		// if & is overloaded, use the ugly version
324 | 		if constexpr ( requires { obj.operator&(); } )
325 | 			return reinterpret_cast<T*>
326 | 			(&const_cast<char&>(reinterpret_cast<const volatile char&>(obj)));
327 | 		else
328 | 			return &obj;
329 | 	#else
330 | 		return std::address_of(obj);
331 | 	#endif
332 | }
333 | 
334 | #endif // eof
335 | 					  
336 | 


--------------------------------------------------------------------------------
/include/swl/variant_visit.hpp:
--------------------------------------------------------------------------------
  1 | #ifdef SWL_CPP_LIBRARY_VARIANT_HPP
  2 | 
  3 | // ========================= visit dispatcher
  4 | 
  5 | template <class Fn, class... Vars>
  6 | using rtype_visit = decltype( ( std::declval<Fn>()( std::declval<Vars>().template unsafe_get<0>()... ) ) );
  7 | 
  8 | template <class Fn, class Var>
  9 | using rtype_index_visit = decltype( ( std::declval<Fn>()( std::declval<Var>().template unsafe_get<0>(), 
 10 | 								 	  std::integral_constant<std::size_t, 0>{} ) ) 
 11 | 								  );
 12 | 
 13 | inline namespace v1 {
 14 | 
 15 | #if defined(__GNUC__) || defined( __clang__ ) || defined( __INTEL_COMPILER )
 16 | 	#define DeclareUnreachable() __builtin_unreachable()
 17 | #elif defined (_MSC_VER)
 18 | 	#define DeclareUnreachable() __assume(false)
 19 | #else
 20 | 	#error "Compiler not supported, please file an issue."
 21 | #endif
 22 | 
 23 | #define DEC(N) X((N)) X((N) + 1) X((N) + 2) X((N) + 3) X((N) + 4) X((N) + 5) X((N) + 6) X((N) + 7) X((N) + 8) X((N) + 9)
 24 | 
 25 | #define SEQ30(N) DEC( (N) + 0 ) DEC( (N) + 10 ) DEC( (N) + 20 ) 
 26 | #define SEQ100(N) SEQ30((N) + 0) SEQ30((N) + 30) SEQ30((N) + 60) DEC((N) + 90) 
 27 | #define SEQ200(N) SEQ100((N) + 0) SEQ100((N) + 100)
 28 | #define SEQ400(N) SEQ200((N) + 0) SEQ200((N) + 200)
 29 | #define CAT(M, N) M##N
 30 | #define CAT2(M, N) CAT(M, N)
 31 | #define INJECTSEQ(N) CAT2(SEQ, N)(0)
 32 | 
 33 | // single-visitation
 34 | 
 35 | template <unsigned Offset, class Rtype, class Fn, class V>
 36 | constexpr Rtype single_visit_tail(Fn&& fn, V&& v){
 37 | 
 38 | 	constexpr auto RemainingIndex = std::decay_t<V>::size - Offset;
 39 | 	
 40 | 	#define X(N) case (N + Offset) : \
 41 | 		if constexpr (N < RemainingIndex) { \
 42 | 			return static_cast<Fn&&>(fn)( static_cast<V&&>(v).template unsafe_get<N+Offset>() ); \
 43 | 			break; \
 44 | 		} else DeclareUnreachable();
 45 | 
 46 | 	#define SEQSIZE 200
 47 | 	
 48 | 	switch( v.index() ){
 49 | 	
 50 | 		INJECTSEQ(SEQSIZE)
 51 | 		
 52 | 		default : 
 53 | 			if constexpr (SEQSIZE < RemainingIndex)
 54 | 				return vimpl::single_visit_tail<Offset + SEQSIZE, Rtype>(static_cast<Fn&&>(fn), static_cast<V&&>(v));
 55 | 			else 
 56 | 				DeclareUnreachable();
 57 | 	}
 58 | 	
 59 | 	#undef X
 60 | 	#undef SEQSIZE
 61 | }
 62 | 
 63 | template <unsigned Offset, class Rtype, class Fn, class V>
 64 | constexpr Rtype single_visit_w_index_tail(Fn&& fn, V&& v){
 65 | 
 66 | 	constexpr auto RemainingIndex = std::decay_t<V>::size - Offset;
 67 | 	
 68 | 	#define X(N) case (N + Offset) : \
 69 | 		if constexpr (N < RemainingIndex) { \
 70 | 			return static_cast<Fn&&>(fn)( static_cast<V&&>(v).template unsafe_get<N+Offset>(), std::integral_constant<unsigned, N+Offset>{} ); \
 71 | 			break; \
 72 | 		} else DeclareUnreachable();
 73 | 	
 74 | 	#define SEQSIZE 200
 75 | 	
 76 | 	switch( v.index() ){
 77 | 	
 78 | 		INJECTSEQ(SEQSIZE)
 79 | 		
 80 | 		default : 
 81 | 			if constexpr (SEQSIZE < RemainingIndex)
 82 | 				return vimpl::single_visit_w_index_tail<Offset + SEQSIZE, Rtype>(static_cast<Fn&&>(fn), static_cast<V&&>(v));
 83 | 			else 
 84 | 				DeclareUnreachable();
 85 | 	}
 86 | 	
 87 | 	#undef X
 88 | 	#undef SEQSIZE
 89 | }
 90 | 
 91 | template <class Fn, class V>
 92 | constexpr decltype(auto) visit(Fn&& fn, V&& v){
 93 | 	return vimpl::single_visit_tail<0, rtype_visit<Fn&&, V&&>>(SWL_FWD(fn), SWL_FWD(v));
 94 | }
 95 | 
 96 | template <class Fn, class Head, class... Tail>
 97 | constexpr decltype(auto) multi_visit(Fn&& fn, Head&& head, Tail&&... tail){
 98 | 	
 99 | 	// visit them one by one, starting with the last
100 | 	auto vis = [&fn, &head] (auto&&... args) -> decltype(auto) {
101 | 		return vimpl::visit( [&fn, &args...] (auto&& elem) -> decltype(auto) {
102 | 			return SWL_FWD(fn)( SWL_FWD(elem), SWL_FWD(args)... );
103 | 		}, SWL_FWD(head) );
104 | 	};
105 | 	
106 | 	if constexpr (sizeof...(tail) == 0)
107 | 		return SWL_FWD(vis)();
108 | 	else if constexpr (sizeof...(tail) == 1)
109 | 		return vimpl::visit( SWL_FWD(vis), SWL_FWD(tail)... );
110 | 	else
111 | 		return vimpl::multi_visit(SWL_FWD(vis), SWL_FWD(tail)...);
112 | }
113 | 
114 | #undef DEC
115 | #undef SEQ30
116 | #undef SEQ100
117 | #undef SEQ200
118 | #undef SEQ400
119 | #undef DeclareUnreachable
120 | #undef CAT
121 | #undef CAT2
122 | #undef INJECTSEQ
123 | 
124 | }
125 | 
126 | 
127 | #endif


--------------------------------------------------------------------------------
/tests/archetypes.ipp:
--------------------------------------------------------------------------------
  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 | #ifndef DEFINE_BASE
 10 | #define DEFINE_BASE(Name) ::ArchetypeBases::NullBase
 11 | #endif
 12 | #ifndef DEFINE_EXPLICIT
 13 | #define DEFINE_EXPLICIT
 14 | #endif
 15 | #ifndef DEFINE_NOEXCEPT
 16 | #define DEFINE_NOEXCEPT
 17 | #endif
 18 | #ifndef DEFINE_CONSTEXPR
 19 | #ifdef TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 20 | #define DEFINE_CONSTEXPR
 21 | #else // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 22 | #define DEFINE_CONSTEXPR constexpr
 23 | #endif // TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR
 24 | #endif
 25 | #ifndef DEFINE_ASSIGN_CONSTEXPR
 26 | #if TEST_STD_VER >= 14
 27 | #define DEFINE_ASSIGN_CONSTEXPR DEFINE_CONSTEXPR
 28 | #else
 29 | #define DEFINE_ASSIGN_CONSTEXPR
 30 | #endif
 31 | #endif
 32 | #ifndef DEFINE_CTOR
 33 | #define DEFINE_CTOR = default
 34 | #endif
 35 | #ifndef DEFINE_DEFAULT_CTOR
 36 | #define DEFINE_DEFAULT_CTOR DEFINE_CTOR
 37 | #endif
 38 | #ifndef DEFINE_ASSIGN
 39 | #define DEFINE_ASSIGN = default
 40 | #endif
 41 | #ifndef DEFINE_DTOR
 42 | #define DEFINE_DTOR(Name)
 43 | #endif
 44 | 
 45 | struct AllCtors : DEFINE_BASE(AllCtors) {
 46 |   using Base = DEFINE_BASE(AllCtors);
 47 |   using Base::Base;
 48 |   using Base::operator=;
 49 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 50 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors const&) DEFINE_NOEXCEPT DEFINE_CTOR;
 51 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR AllCtors(AllCtors &&) DEFINE_NOEXCEPT DEFINE_CTOR;
 52 |   DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 53 |   DEFINE_ASSIGN_CONSTEXPR AllCtors& operator=(AllCtors &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 54 |   DEFINE_DTOR(AllCtors)
 55 | };
 56 | 
 57 | struct NoCtors : DEFINE_BASE(NoCtors) {
 58 |   using Base = DEFINE_BASE(NoCtors);
 59 |   DEFINE_EXPLICIT NoCtors() DEFINE_NOEXCEPT = delete;
 60 |   DEFINE_EXPLICIT NoCtors(NoCtors const&) DEFINE_NOEXCEPT = delete;
 61 |   NoCtors& operator=(NoCtors const&) DEFINE_NOEXCEPT = delete;
 62 |   DEFINE_DTOR(NoCtors)
 63 | };
 64 | 
 65 | struct NoDefault : DEFINE_BASE(NoDefault) {
 66 |   using Base = DEFINE_BASE(NoDefault);
 67 |   using Base::Base;
 68 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NoDefault() DEFINE_NOEXCEPT = delete;
 69 |   DEFINE_DTOR(NoDefault)
 70 | };
 71 | 
 72 | struct DefaultOnly : DEFINE_BASE(DefaultOnly) {
 73 |   using Base = DEFINE_BASE(DefaultOnly);
 74 |   using Base::Base;
 75 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR DefaultOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 76 |   DefaultOnly(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
 77 |   DefaultOnly& operator=(DefaultOnly const&) DEFINE_NOEXCEPT = delete;
 78 |   DEFINE_DTOR(DefaultOnly)
 79 | };
 80 | 
 81 | struct Copyable : DEFINE_BASE(Copyable) {
 82 |   using Base = DEFINE_BASE(Copyable);
 83 |   using Base::Base;
 84 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 85 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR Copyable(Copyable const &) DEFINE_NOEXCEPT DEFINE_CTOR;
 86 |   Copyable &operator=(Copyable const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 87 |   DEFINE_DTOR(Copyable)
 88 | };
 89 | 
 90 | struct CopyOnly : DEFINE_BASE(CopyOnly) {
 91 |   using Base = DEFINE_BASE(CopyOnly);
 92 |   using Base::Base;
 93 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
 94 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_CTOR;
 95 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyOnly(CopyOnly &&) DEFINE_NOEXCEPT = delete;
 96 |   CopyOnly &operator=(CopyOnly const &) DEFINE_NOEXCEPT DEFINE_ASSIGN;
 97 |   CopyOnly &operator=(CopyOnly &&) DEFINE_NOEXCEPT = delete;
 98 |   DEFINE_DTOR(CopyOnly)
 99 | };
100 | 
101 | struct NonCopyable : DEFINE_BASE(NonCopyable) {
102 |   using Base = DEFINE_BASE(NonCopyable);
103 |   using Base::Base;
104 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
105 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR NonCopyable(NonCopyable const &) DEFINE_NOEXCEPT = delete;
106 |   NonCopyable &operator=(NonCopyable const &) DEFINE_NOEXCEPT = delete;
107 |   DEFINE_DTOR(NonCopyable)
108 | };
109 | 
110 | struct MoveOnly : DEFINE_BASE(MoveOnly) {
111 |   using Base = DEFINE_BASE(MoveOnly);
112 |   using Base::Base;
113 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
114 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveOnly(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_CTOR;
115 |   MoveOnly &operator=(MoveOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
116 |   DEFINE_DTOR(MoveOnly)
117 | };
118 | 
119 | struct CopyAssignable : DEFINE_BASE(CopyAssignable) {
120 |   using Base = DEFINE_BASE(CopyAssignable);
121 |   using Base::Base;
122 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignable() DEFINE_NOEXCEPT = delete;
123 |   CopyAssignable& operator=(CopyAssignable const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
124 |   DEFINE_DTOR(CopyAssignable)
125 | };
126 | 
127 | struct CopyAssignOnly : DEFINE_BASE(CopyAssignOnly) {
128 |   using Base = DEFINE_BASE(CopyAssignOnly);
129 |   using Base::Base;
130 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR CopyAssignOnly() DEFINE_NOEXCEPT = delete;
131 |   CopyAssignOnly& operator=(CopyAssignOnly const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
132 |   CopyAssignOnly& operator=(CopyAssignOnly &&) DEFINE_NOEXCEPT = delete;
133 |   DEFINE_DTOR(CopyAssignOnly)
134 | };
135 | 
136 | struct MoveAssignOnly : DEFINE_BASE(MoveAssignOnly) {
137 |   using Base = DEFINE_BASE(MoveAssignOnly);
138 |   using Base::Base;
139 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR MoveAssignOnly() DEFINE_NOEXCEPT = delete;
140 |   MoveAssignOnly& operator=(MoveAssignOnly const&) DEFINE_NOEXCEPT = delete;
141 |   MoveAssignOnly& operator=(MoveAssignOnly &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
142 |   DEFINE_DTOR(MoveAssignOnly)
143 | };
144 | 
145 | struct ConvertingType : DEFINE_BASE(ConvertingType) {
146 |   using Base = DEFINE_BASE(ConvertingType);
147 |   using Base::Base;
148 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType() DEFINE_NOEXCEPT DEFINE_DEFAULT_CTOR;
149 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_CTOR;
150 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_CTOR;
151 |   ConvertingType& operator=(ConvertingType const&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
152 |   ConvertingType& operator=(ConvertingType &&) DEFINE_NOEXCEPT DEFINE_ASSIGN;
153 |   template <class ...Args>
154 |   DEFINE_EXPLICIT DEFINE_CONSTEXPR ConvertingType(Args&&...) DEFINE_NOEXCEPT {}
155 |   template <class Arg>
156 |   ConvertingType& operator=(Arg&&) DEFINE_NOEXCEPT { return *this; }
157 |   DEFINE_DTOR(ConvertingType)
158 | };
159 | 
160 | template <template <class...> class List>
161 | using ApplyTypes = List<
162 |     AllCtors,
163 |     NoCtors,
164 |     NoDefault,
165 |     DefaultOnly,
166 |     Copyable,
167 |     CopyOnly,
168 |     NonCopyable,
169 |     MoveOnly,
170 |     CopyAssignable,
171 |     CopyAssignOnly,
172 |     MoveAssignOnly,
173 |     ConvertingType
174 |   >;
175 | 
176 | #undef DEFINE_BASE
177 | #undef DEFINE_EXPLICIT
178 | #undef DEFINE_NOEXCEPT
179 | #undef DEFINE_CONSTEXPR
180 | #undef DEFINE_ASSIGN_CONSTEXPR
181 | #undef DEFINE_CTOR
182 | #undef DEFINE_DEFAULT_CTOR
183 | #undef DEFINE_ASSIGN
184 | #undef DEFINE_DTOR
185 | 


--------------------------------------------------------------------------------
/tests/poisoned_hash_helper.h:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | #ifndef SUPPORT_POISONED_HASH_HELPER_H
 10 | #define SUPPORT_POISONED_HASH_HELPER_H
 11 | 
 12 | #include <type_traits>
 13 | #include <cassert>
 14 | 
 15 | #include "test_macros.h"
 16 | #include "test_workarounds.h"
 17 | 
 18 | #if TEST_STD_VER < 11
 19 | #error this header may only be used in C++11 or newer
 20 | #endif
 21 | 
 22 | template <class ...Args> struct TypeList;
 23 | 
 24 | // Test that the specified Hash meets the requirements of an enabled hash
 25 | template <class Hash, class Key, class InputKey = Key>
 26 | void test_hash_enabled(InputKey const& key = InputKey{});
 27 | 
 28 | template <class T, class InputKey = T>
 29 | void test_hash_enabled_for_type(InputKey const& key = InputKey{}) {
 30 |   return test_hash_enabled<std::hash<T>, T, InputKey>(key);
 31 | }
 32 | 
 33 | // Test that the specified Hash meets the requirements of a disabled hash.
 34 | template <class Hash, class Key>
 35 | void test_hash_disabled();
 36 | 
 37 | template <class T>
 38 | void test_hash_disabled_for_type() {
 39 |   return test_hash_disabled<std::hash<T>, T>();
 40 | }
 41 | 
 42 | namespace PoisonedHashDetail {
 43 |   enum Enum {};
 44 |   enum EnumClass : bool {};
 45 |   struct Class {};
 46 | }
 47 | 
 48 | // Each header that declares the template hash provides enabled
 49 | // specializations of hash for nullptr t and all cv-unqualified
 50 | // arithmetic, enumeration, and pointer types.
 51 | using LibraryHashTypes = TypeList<
 52 | #if TEST_STD_VER > 14
 53 |       decltype(nullptr),
 54 | #endif
 55 |       bool,
 56 |       char,
 57 |       signed char,
 58 |       unsigned char,
 59 |       wchar_t,
 60 | #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
 61 |       char16_t,
 62 |       char32_t,
 63 | #endif
 64 |       short,
 65 |       unsigned short,
 66 |       int,
 67 |       unsigned int,
 68 |       long,
 69 |       unsigned long,
 70 |       long long,
 71 |       unsigned long long,
 72 | #ifndef _LIBCPP_HAS_NO_INT128
 73 |       __int128_t,
 74 |       __uint128_t,
 75 | #endif
 76 |       float,
 77 |       double,
 78 |       long double,
 79 | #if TEST_STD_VER >= 14
 80 |       // Enum types
 81 |       PoisonedHashDetail::Enum,
 82 |       PoisonedHashDetail::EnumClass,
 83 | #endif
 84 |       // pointer types
 85 |       void*,
 86 |       void const*,
 87 |       PoisonedHashDetail::Class*
 88 |     >;
 89 | 
 90 | 
 91 | // Test that each of the library hash specializations for  arithmetic types,
 92 | // enum types, and pointer types are available and enabled.
 93 | template <class Types = LibraryHashTypes>
 94 | void test_library_hash_specializations_available(Types = Types{});
 95 | 
 96 | 
 97 | namespace PoisonedHashDetail {
 98 | 
 99 | template <class T, class = typename T::foo_bar_baz>
100 | constexpr bool instantiate(int) { return true; }
101 | template <class> constexpr bool instantiate(long) { return true; }
102 | template <class T> constexpr bool instantiate() { return instantiate<T>(0); }
103 | 
104 | template <class To>
105 | struct ConvertibleToSimple {
106 |   operator To() const {
107 |     return To{};
108 |   }
109 | };
110 | 
111 | template <class To>
112 | struct ConvertibleTo {
113 |   To to{};
114 |   operator To&() & { return to; }
115 |   operator To const&() const & { return to; }
116 |   operator To&&() && { return std::move(to); }
117 |   operator To const&&() const && { return std::move(to); }
118 | };
119 | 
120 | template <class HashExpr,
121 |          class Res = typename std::result_of<HashExpr>::type>
122 | constexpr bool can_hash(int) {
123 |   return std::is_same<Res, size_t>::value;
124 | }
125 | template <class> constexpr bool can_hash(long) { return false; }
126 | template <class T> constexpr bool can_hash() { return can_hash<T>(0); }
127 | 
128 | } // namespace PoisonedHashDetail
129 | 
130 | template <class Hash, class Key, class InputKey>
131 | void test_hash_enabled(InputKey const& key) {
132 |   using namespace PoisonedHashDetail;
133 | 
134 |   static_assert(std::is_destructible<Hash>::value, "");
135 |   // Enabled hash requirements
136 |   static_assert(std::is_default_constructible<Hash>::value, "");
137 |   static_assert(std::is_copy_constructible<Hash>::value, "");
138 |   static_assert(std::is_move_constructible<Hash>::value, "");
139 |   static_assert(std::is_copy_assignable<Hash>::value, "");
140 |   static_assert(std::is_move_assignable<Hash>::value, "");
141 | 
142 | #if TEST_STD_VER > 14
143 |   static_assert(std::is_swappable<Hash>::value, "");
144 | #elif defined(_LIBCPP_VERSION)
145 |   static_assert(std::__is_swappable<Hash>::value, "");
146 | #endif
147 | 
148 |   // Hashable requirements
149 |   static_assert(can_hash<Hash(Key&)>(), "");
150 |   static_assert(can_hash<Hash(Key const&)>(), "");
151 |   static_assert(can_hash<Hash(Key&&)>(), "");
152 |   static_assert(can_hash<Hash const&(Key&)>(), "");
153 |   static_assert(can_hash<Hash const&(Key const&)>(), "");
154 |   static_assert(can_hash<Hash const&(Key&&)>(), "");
155 | 
156 |   static_assert(can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
157 |   static_assert(can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
158 |   static_assert(can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
159 | 
160 |   static_assert(can_hash<Hash(ConvertibleTo<Key>&)>(), "");
161 |   static_assert(can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
162 |   static_assert(can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
163 |   static_assert(can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
164 | 
165 |   const Hash h{};
166 |   assert(h(key) == h(key));
167 | 
168 | }
169 | 
170 | template <class Hash, class Key>
171 | void test_hash_disabled() {
172 |   using namespace PoisonedHashDetail;
173 | 
174 |   // Disabled hash requirements
175 |   static_assert(!std::is_default_constructible<Hash>::value, "");
176 |   static_assert(!std::is_copy_constructible<Hash>::value, "");
177 |   static_assert(!std::is_move_constructible<Hash>::value, "");
178 |   static_assert(!std::is_copy_assignable<Hash>::value, "");
179 |   static_assert(!std::is_move_assignable<Hash>::value, "");
180 | 
181 |   static_assert(!std::is_function<
182 |       typename std::remove_pointer<
183 |           typename std::remove_reference<Hash>::type
184 |       >::type
185 |     >::value, "");
186 | 
187 |   // Hashable requirements
188 |   static_assert(!can_hash<Hash(Key&)>(), "");
189 |   static_assert(!can_hash<Hash(Key const&)>(), "");
190 |   static_assert(!can_hash<Hash(Key&&)>(), "");
191 |   static_assert(!can_hash<Hash const&(Key&)>(), "");
192 |   static_assert(!can_hash<Hash const&(Key const&)>(), "");
193 |   static_assert(!can_hash<Hash const&(Key&&)>(), "");
194 | 
195 |   static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&)>(), "");
196 |   static_assert(!can_hash<Hash(ConvertibleToSimple<Key> const&)>(), "");
197 |   static_assert(!can_hash<Hash(ConvertibleToSimple<Key>&&)>(), "");
198 | 
199 |   static_assert(!can_hash<Hash(ConvertibleTo<Key>&)>(), "");
200 |   static_assert(!can_hash<Hash(ConvertibleTo<Key> const&)>(), "");
201 |   static_assert(!can_hash<Hash(ConvertibleTo<Key> &&)>(), "");
202 |   static_assert(!can_hash<Hash(ConvertibleTo<Key> const&&)>(), "");
203 | }
204 | 
205 | 
206 | template <class First, class ...Rest>
207 | struct TypeList<First, Rest...> {
208 |   template <template <class> class Trait, bool Expect = true>
209 |   static constexpr bool assertTrait() {
210 |     static_assert(Trait<First>::value == Expect, "");
211 |     return TypeList<Rest...>::template assertTrait<Trait, Expect>();
212 |   }
213 | 
214 |   template <class Trait>
215 |   static void applyTrait() {
216 |     Trait::template apply<First>();
217 |     TypeList<Rest...>::template applyTrait<Trait>();
218 |   }
219 | };
220 | 
221 | template <>
222 | struct TypeList<> {
223 |   template <template <class> class Trait, bool Expect = true>
224 |   static constexpr bool assertTrait() {
225 |     return true;
226 |   }
227 |   template <class Trait>
228 |   static void applyTrait() {}
229 | };
230 | 
231 | 
232 | struct TestLibraryTrait {
233 |     template <class Type>
234 |     static void apply() { test_hash_enabled<std::hash<Type>, Type>(); }
235 | };
236 | 
237 | template <class Types>
238 | void test_library_hash_specializations_available(Types) {
239 |   Types::template applyTrait<TestLibraryTrait >();
240 | }
241 | 
242 | #endif // SUPPORT_POISONED_HASH_HELPER_H
243 | 


--------------------------------------------------------------------------------
/tests/swl_assert.hpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <iostream>
 3 | 
 4 | constexpr auto&& failure_token = "##FAIL##";
 5 | constexpr auto&& expected_exit_token = "##SUCCESS_EXIT##";
 6 | 
 7 | // replace the good old assert with this to make sure we can detect failure with a string search in the program output
 8 | 
 9 | #define SWL_ASSERT(X) \
10 | 	do { \
11 | 	if(not (X)) std::cout << failure_token << " Assertion failed : [" << #X << "] in " << __FILE__ " at " << __LINE__ << " \n"; \
12 | 	} while(0)
13 | 
14 | #define SWL_END_TEST_SIGNAL std::cout << "\n " << expected_exit_token << " \n";


--------------------------------------------------------------------------------
/tests/test_convertible.h:
--------------------------------------------------------------------------------
 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 | #ifndef SUPPORT_TEST_CONVERTIBLE_H
10 | #define SUPPORT_TEST_CONVERTIBLE_H
11 | 
12 | // "test_convertible<Tp, Args...>()" is a metafunction used to check if 'Tp'
13 | // is implicitly convertible from 'Args...' for any number of arguments,
14 | // Unlike 'std::is_convertible' which only allows checking for single argument
15 | // conversions.
16 | 
17 | #include <type_traits>
18 | 
19 | #include "test_macros.h"
20 | 
21 | #if TEST_STD_VER < 11
22 | #error test_convertible.h requires C++11 or newer
23 | #endif
24 | 
25 | namespace detail {
26 |     template <class Tp> void eat_type(Tp);
27 | 
28 |     template <class Tp, class ...Args>
29 |     constexpr auto test_convertible_imp(int)
30 |         -> decltype(eat_type<Tp>({std::declval<Args>()...}), true)
31 |     { return true; }
32 | 
33 |     template <class Tp, class ...Args>
34 |     constexpr auto test_convertible_imp(long) -> bool { return false; }
35 | }
36 | 
37 | template <class Tp, class ...Args>
38 | constexpr bool test_convertible()
39 | { return detail::test_convertible_imp<Tp, Args...>(0); }
40 | 
41 | #endif // SUPPORT_TEST_CONVERTIBLE_H
42 | 


--------------------------------------------------------------------------------
/tests/test_macros.h:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===---------------------------- test_macros.h ---------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | #ifndef SUPPORT_TEST_MACROS_HPP
 11 | #define SUPPORT_TEST_MACROS_HPP
 12 | 
 13 | // Attempt to get STL specific macros like _LIBCPP_VERSION using the most
 14 | // minimal header possible. If we're testing libc++, we should use `<__config>`.
 15 | // If <__config> isn't available, fall back to <ciso646>.
 16 | #ifdef __has_include
 17 | # if __has_include("<__config>")
 18 | #   include <__config>
 19 | #   define TEST_IMP_INCLUDED_HEADER
 20 | # endif
 21 | #endif
 22 | #ifndef TEST_IMP_INCLUDED_HEADER
 23 | #include <ciso646>
 24 | #endif
 25 | 
 26 | #if defined(__GNUC__)
 27 | #pragma GCC diagnostic push
 28 | #pragma GCC diagnostic ignored "-Wvariadic-macros"
 29 | #endif
 30 | 
 31 | #define TEST_STRINGIZE_IMPL(x) #x
 32 | #define TEST_STRINGIZE(x) TEST_STRINGIZE_IMPL(x)
 33 | 
 34 | #define TEST_CONCAT1(X, Y) X##Y
 35 | #define TEST_CONCAT(X, Y) TEST_CONCAT1(X, Y)
 36 | 
 37 | #ifdef __has_feature
 38 | #define TEST_HAS_FEATURE(X) __has_feature(X)
 39 | #else
 40 | #define TEST_HAS_FEATURE(X) 0
 41 | #endif
 42 | 
 43 | #ifndef __has_include
 44 | #define __has_include(...) 0
 45 | #endif
 46 | 
 47 | #ifdef __has_extension
 48 | #define TEST_HAS_EXTENSION(X) __has_extension(X)
 49 | #else
 50 | #define TEST_HAS_EXTENSION(X) 0
 51 | #endif
 52 | 
 53 | #ifdef __has_warning
 54 | #define TEST_HAS_WARNING(X) __has_warning(X)
 55 | #else
 56 | #define TEST_HAS_WARNING(X) 0
 57 | #endif
 58 | 
 59 | #ifdef __has_builtin
 60 | #define TEST_HAS_BUILTIN(X) __has_builtin(X)
 61 | #else
 62 | #define TEST_HAS_BUILTIN(X) 0
 63 | #endif
 64 | #ifdef __is_identifier
 65 | // '__is_identifier' returns '0' if '__x' is a reserved identifier provided by
 66 | // the compiler and '1' otherwise.
 67 | #define TEST_HAS_BUILTIN_IDENTIFIER(X) !__is_identifier(X)
 68 | #else
 69 | #define TEST_HAS_BUILTIN_IDENTIFIER(X) 0
 70 | #endif
 71 | 
 72 | #if defined(__EDG__)
 73 | # define TEST_COMPILER_EDG
 74 | #elif defined(__clang__)
 75 | # define TEST_COMPILER_CLANG
 76 | # if defined(__apple_build_version__)
 77 | #  define TEST_COMPILER_APPLE_CLANG
 78 | # endif
 79 | #elif defined(_MSC_VER)
 80 | # define TEST_COMPILER_C1XX
 81 | #elif defined(__GNUC__)
 82 | # define TEST_COMPILER_GCC
 83 | #endif
 84 | 
 85 | #if defined(__apple_build_version__)
 86 | #define TEST_APPLE_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 87 | #elif defined(__clang_major__)
 88 | #define TEST_CLANG_VER (__clang_major__ * 100) + __clang_minor__
 89 | #elif defined(__GNUC__)
 90 | #define TEST_GCC_VER (__GNUC__ * 100 + __GNUC_MINOR__)
 91 | #define TEST_GCC_VER_NEW (TEST_GCC_VER * 10 + __GNUC_PATCHLEVEL__)
 92 | #endif
 93 | 
 94 | /* Make a nice name for the standard version */
 95 | #ifndef TEST_STD_VER
 96 | #if  __cplusplus <= 199711L
 97 | # define TEST_STD_VER 3
 98 | #elif __cplusplus <= 201103L
 99 | # define TEST_STD_VER 11
100 | #elif __cplusplus <= 201402L
101 | # define TEST_STD_VER 14
102 | #elif __cplusplus <= 201703L
103 | # define TEST_STD_VER 17
104 | #elif __cplusplus <= 202002L
105 | # define TEST_STD_VER 20
106 | #else
107 | # define TEST_STD_VER 99    // greater than current standard
108 | // This is deliberately different than _LIBCPP_STD_VER to discourage matching them up.
109 | #endif
110 | #endif
111 | 
112 | // Attempt to deduce the GLIBC version
113 | #if (defined(__has_include) && __has_include(<features.h>)) || \
114 |     defined(__linux__)
115 | #include <features.h>
116 | #if defined(__GLIBC_PREREQ)
117 | #define TEST_HAS_GLIBC
118 | #define TEST_GLIBC_PREREQ(major, minor) __GLIBC_PREREQ(major, minor)
119 | #endif
120 | #endif
121 | 
122 | #if TEST_STD_VER >= 11
123 | # define TEST_ALIGNOF(...) alignof(__VA_ARGS__)
124 | # define TEST_ALIGNAS(...) alignas(__VA_ARGS__)
125 | # define TEST_CONSTEXPR constexpr
126 | # define TEST_NOEXCEPT noexcept
127 | # define TEST_NOEXCEPT_FALSE noexcept(false)
128 | # define TEST_NOEXCEPT_COND(...) noexcept(__VA_ARGS__)
129 | #else
130 | #   if defined(TEST_COMPILER_CLANG)
131 | #    define TEST_ALIGNOF(...) _Alignof(__VA_ARGS__)
132 | #   else
133 | #    define TEST_ALIGNOF(...) __alignof(__VA_ARGS__)
134 | #   endif
135 | # define TEST_ALIGNAS(...) __attribute__((__aligned__(__VA_ARGS__)))
136 | # define TEST_CONSTEXPR
137 | # define TEST_NOEXCEPT throw()
138 | # define TEST_NOEXCEPT_FALSE
139 | # define TEST_NOEXCEPT_COND(...)
140 | #endif
141 | 
142 | #if TEST_STD_VER >= 17
143 | # define TEST_THROW_SPEC(...)
144 | #else
145 | # define TEST_THROW_SPEC(...) throw(__VA_ARGS__)
146 | #endif
147 | 
148 | #if TEST_STD_VER >= 14
149 | # define TEST_CONSTEXPR_CXX14 constexpr
150 | #else
151 | # define TEST_CONSTEXPR_CXX14
152 | #endif
153 | 
154 | #if TEST_STD_VER >= 17
155 | # define TEST_CONSTEXPR_CXX17 constexpr
156 | #else
157 | # define TEST_CONSTEXPR_CXX17
158 | #endif
159 | 
160 | #if TEST_STD_VER >= 20
161 | # define TEST_CONSTEXPR_CXX20 constexpr
162 | #else
163 | # define TEST_CONSTEXPR_CXX20
164 | #endif
165 | 
166 | // Sniff out to see if the underlying C library has C11 features
167 | // This is cribbed from __config; but lives here as well because we can't assume libc++
168 | #if __ISO_C_VISIBLE >= 2011 || TEST_STD_VER >= 11
169 | #  if defined(__FreeBSD__)
170 | #    if __FreeBSD_version >= 1300064 || \
171 |        (__FreeBSD_version >= 1201504 && __FreeBSD_version < 1300000)
172 | #      define TEST_HAS_TIMESPEC_GET
173 | #    endif
174 | #    define TEST_HAS_ALIGNED_ALLOC
175 | #    define TEST_HAS_QUICK_EXIT
176 | #  elif defined(__BIONIC__)
177 | #    if __ANDROID_API__ >= 21
178 | #      define TEST_HAS_QUICK_EXIT
179 | #    endif
180 | #    if __ANDROID_API__ >= 28
181 | #      define TEST_HAS_ALIGNED_ALLOC
182 | #    endif
183 | #    if __ANDROID_API__ >= 29
184 | #      define TEST_HAS_TIMESPEC_GET
185 | #    endif
186 | #  elif defined(__Fuchsia__) || defined(__wasi__) || defined(__NetBSD__)
187 | #    define TEST_HAS_QUICK_EXIT
188 | #    define TEST_HAS_ALIGNED_ALLOC
189 | #    define TEST_HAS_TIMESPEC_GET
190 | #  elif defined(__linux__)
191 | // This block preserves the old behavior used by include/__config:
192 | // _LIBCPP_GLIBC_PREREQ would be defined to 0 if __GLIBC_PREREQ was not
193 | // available. The configuration here may be too vague though, as Bionic, uClibc,
194 | // newlib, etc may all support these features but need to be configured.
195 | #    if defined(TEST_GLIBC_PREREQ)
196 | #      if TEST_GLIBC_PREREQ(2, 15)
197 | #        define TEST_HAS_QUICK_EXIT
198 | #      endif
199 | #      if TEST_GLIBC_PREREQ(2, 17)
200 | #        define TEST_HAS_ALIGNED_ALLOC
201 | #        define TEST_HAS_TIMESPEC_GET
202 | #      endif
203 | #    elif defined(_LIBCPP_HAS_MUSL_LIBC)
204 | #      define TEST_HAS_QUICK_EXIT
205 | #      define TEST_HAS_ALIGNED_ALLOC
206 | #      define TEST_HAS_TIMESPEC_GET
207 | #    endif
208 | #  elif defined(_WIN32)
209 | #    if defined(_MSC_VER) && !defined(__MINGW32__)
210 | #      define TEST_HAS_QUICK_EXIT
211 | #      define TEST_HAS_ALIGNED_ALLOC
212 | #      define TEST_HAS_TIMESPEC_GET
213 | #    endif
214 | #  elif defined(__APPLE__)
215 |      // timespec_get and aligned_alloc were introduced in macOS 10.15 and
216 |      // aligned releases
217 | #    if (__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 101500 || \
218 |          __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ >= 130000 || \
219 |          __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ >= 130000 || \
220 |          __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ >= 60000)
221 | #      define TEST_HAS_ALIGNED_ALLOC
222 | #      define TEST_HAS_TIMESPEC_GET
223 | #    endif
224 | #  endif // __APPLE__
225 | #endif
226 | 
227 | /* Features that were introduced in C++14 */
228 | #if TEST_STD_VER >= 14
229 | #define TEST_HAS_EXTENDED_CONSTEXPR
230 | #define TEST_HAS_VARIABLE_TEMPLATES
231 | #endif
232 | 
233 | /* Features that were introduced in C++17 */
234 | #if TEST_STD_VER >= 17
235 | #endif
236 | 
237 | /* Features that were introduced after C++17 */
238 | #if TEST_STD_VER > 17
239 | #endif
240 | 
241 | 
242 | #define TEST_ALIGNAS_TYPE(...) TEST_ALIGNAS(TEST_ALIGNOF(__VA_ARGS__))
243 | 
244 | #if !TEST_HAS_FEATURE(cxx_rtti) && !defined(__cpp_rtti) \
245 |     && !defined(__GXX_RTTI)
246 | #define TEST_HAS_NO_RTTI
247 | #endif
248 | 
249 | #if !defined(TEST_HAS_NO_RTTI)
250 | # define RTTI_ASSERT(X) assert(X)
251 | #else
252 | # define RTTI_ASSERT(X)
253 | #endif
254 | 
255 | #if !TEST_HAS_FEATURE(cxx_exceptions) && !defined(__cpp_exceptions) \
256 |      && !defined(__EXCEPTIONS)
257 | #define TEST_HAS_NO_EXCEPTIONS
258 | #endif
259 | 
260 | #if TEST_HAS_FEATURE(address_sanitizer) || TEST_HAS_FEATURE(memory_sanitizer) || \
261 |     TEST_HAS_FEATURE(thread_sanitizer)
262 | #define TEST_HAS_SANITIZERS
263 | #endif
264 | 
265 | #if defined(_LIBCPP_NORETURN)
266 | #define TEST_NORETURN _LIBCPP_NORETURN
267 | #else
268 | #define TEST_NORETURN [[noreturn]]
269 | #endif
270 | 
271 | #if defined(_LIBCPP_HAS_NO_ALIGNED_ALLOCATION) || \
272 |   (!(TEST_STD_VER > 14 || \
273 |     (defined(__cpp_aligned_new) && __cpp_aligned_new >= 201606L)))
274 | #define TEST_HAS_NO_ALIGNED_ALLOCATION
275 | #endif
276 | 
277 | #if defined(_LIBCPP_SAFE_STATIC)
278 | #define TEST_SAFE_STATIC _LIBCPP_SAFE_STATIC
279 | #else
280 | #define TEST_SAFE_STATIC
281 | #endif
282 | 
283 | #if !defined(__cpp_impl_three_way_comparison) \
284 |     && (!defined(_MSC_VER) || defined(__clang__) || _MSC_VER < 1920 || _MSVC_LANG <= 201703L)
285 | #define TEST_HAS_NO_SPACESHIP_OPERATOR
286 | #endif
287 | 
288 | #if TEST_STD_VER < 11
289 | #define ASSERT_NOEXCEPT(...)
290 | #define ASSERT_NOT_NOEXCEPT(...)
291 | #else
292 | #define ASSERT_NOEXCEPT(...) \
293 |     static_assert(noexcept(__VA_ARGS__), "Operation must be noexcept")
294 | 
295 | #define ASSERT_NOT_NOEXCEPT(...) \
296 |     static_assert(!noexcept(__VA_ARGS__), "Operation must NOT be noexcept")
297 | #endif
298 | 
299 | /* Macros for testing libc++ specific behavior and extensions */
300 | #if defined(_LIBCPP_VERSION)
301 | #define LIBCPP_ASSERT(...) assert(__VA_ARGS__)
302 | #define LIBCPP_STATIC_ASSERT(...) static_assert(__VA_ARGS__)
303 | #define LIBCPP_ASSERT_NOEXCEPT(...) ASSERT_NOEXCEPT(__VA_ARGS__)
304 | #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ASSERT_NOT_NOEXCEPT(__VA_ARGS__)
305 | #define LIBCPP_ONLY(...) __VA_ARGS__
306 | #else
307 | #define LIBCPP_ASSERT(...) ((void)0)
308 | #define LIBCPP_STATIC_ASSERT(...) ((void)0)
309 | #define LIBCPP_ASSERT_NOEXCEPT(...) ((void)0)
310 | #define LIBCPP_ASSERT_NOT_NOEXCEPT(...) ((void)0)
311 | #define LIBCPP_ONLY(...) ((void)0)
312 | #endif
313 | 
314 | #define TEST_IGNORE_NODISCARD (void)
315 | 
316 | namespace test_macros_detail {
317 | template <class T, class U>
318 | struct is_same { enum { value = 0};} ;
319 | template <class T>
320 | struct is_same<T, T> { enum {value = 1}; };
321 | } // namespace test_macros_detail
322 | 
323 | #define ASSERT_SAME_TYPE(...) \
324 |     static_assert((test_macros_detail::is_same<__VA_ARGS__>::value), \
325 |                  "Types differ unexpectedly")
326 | 
327 | #ifndef TEST_HAS_NO_EXCEPTIONS
328 | #define TEST_THROW(...) throw __VA_ARGS__
329 | #else
330 | #if defined(__GNUC__)
331 | #define TEST_THROW(...) __builtin_abort()
332 | #else
333 | #include <stdlib.h>
334 | #define TEST_THROW(...) ::abort()
335 | #endif
336 | #endif
337 | 
338 | #if defined(__GNUC__) || defined(__clang__)
339 | template <class Tp>
340 | inline
341 | void DoNotOptimize(Tp const& value) {
342 |     asm volatile("" : : "r,m"(value) : "memory");
343 | }
344 | 
345 | template <class Tp>
346 | inline void DoNotOptimize(Tp& value) {
347 | #if defined(__clang__)
348 |   asm volatile("" : "+r,m"(value) : : "memory");
349 | #else
350 |   asm volatile("" : "+m,r"(value) : : "memory");
351 | #endif
352 | }
353 | #else
354 | #include <intrin.h>
355 | template <class Tp>
356 | inline void DoNotOptimize(Tp const& value) {
357 |   const volatile void* volatile unused = __builtin_addressof(value);
358 |   static_cast<void>(unused);
359 |   _ReadWriteBarrier();
360 | }
361 | #endif
362 | 
363 | #if defined(__GNUC__)
364 | #define TEST_ALWAYS_INLINE __attribute__((always_inline))
365 | #define TEST_NOINLINE __attribute__((noinline))
366 | #elif defined(_MSC_VER)
367 | #define TEST_ALWAYS_INLINE __forceinline
368 | #define TEST_NOINLINE __declspec(noinline)
369 | #else
370 | #define TEST_ALWAYS_INLINE
371 | #define TEST_NOINLINE
372 | #endif
373 | 
374 | #ifdef _WIN32
375 | #define TEST_NOT_WIN32(...) ((void)0)
376 | #else
377 | #define TEST_NOT_WIN32(...) __VA_ARGS__
378 | #endif
379 | 
380 | #if defined(__GNUC__)
381 | #pragma GCC diagnostic pop
382 | #endif
383 | 
384 | #endif // SUPPORT_TEST_MACROS_HPP
385 | 


--------------------------------------------------------------------------------
/tests/test_workarounds.h:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | #ifndef SUPPORT_TEST_WORKAROUNDS_H
11 | #define SUPPORT_TEST_WORKAROUNDS_H
12 | 
13 | #include "test_macros.h"
14 | 
15 | #if defined(TEST_COMPILER_EDG)
16 | # define TEST_WORKAROUND_EDG_EXPLICIT_CONSTEXPR // VSO-424280
17 | #endif
18 | 
19 | #if defined(TEST_COMPILER_C1XX)
20 | # if _MSC_VER < 1927
21 | #  define TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE // VSO-117743
22 | # endif
23 | # ifndef _MSC_EXTENSIONS
24 | #  define TEST_WORKAROUND_C1XX_BROKEN_ZA_CTOR_CHECK // VSO-119998
25 | # endif
26 | #endif
27 | 
28 | #if defined(TEST_COMPILER_GCC)
29 | # if __GNUC__ < 9
30 | #  define TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT // GCC-87603
31 | # endif
32 | #endif
33 | 
34 | #endif // SUPPORT_TEST_WORKAROUNDS_H
35 | 


--------------------------------------------------------------------------------
/tests/tests/throwing_conversion.pass.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include <swl/variant.hpp>
 3 | #include <cassert> 
 4 | 
 5 | struct test {
 6 | 	operator int () { throw 0; return 1; }
 7 | };
 8 | 
 9 | int main(){
10 | 
11 | 	swl::variant<int, bool> v{true};
12 | 	
13 | 	test t;
14 | 	
15 | 	try {
16 | 		v.emplace<0>( t );
17 | 	}
18 | 	catch (...) {}
19 | 	
20 | 	assert( v.index() == 1 );
21 | 	assert( get<1>(v) == true );
22 | }
23 | 


--------------------------------------------------------------------------------
/tests/tests/variant.bad_variant_access/bad_variant_access.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // Throwing bad_variant_access is supported starting in macosx10.13
13 | // XFAIL: with_system_cxx_lib=macosx10.12
14 | // XFAIL: with_system_cxx_lib=macosx10.11
15 | // XFAIL: with_system_cxx_lib=macosx10.10
16 | // XFAIL: with_system_cxx_lib=macosx10.9
17 | 
18 | // <variant>
19 | 
20 | /*
21 | 
22 |  class bad_variant_access : public exception {
23 | public:
24 |   bad_variant_access() noexcept;
25 |   virtual const char* what() const noexcept;
26 | };
27 | 
28 | */
29 | 
30 |  
31 | #include <exception>
32 | #include <type_traits>
33 | #include <swl_assert.hpp> 
34 | #include <swl/variant.hpp> 
35 | 
36 | #include "test_macros.h"
37 | 
38 | int main(int, char**) {
39 |   static_assert(std::is_base_of<std::exception, swl::bad_variant_access>::value,
40 |                 "");
41 |   static_assert(noexcept(swl::bad_variant_access{"hello"}), "must be noexcept");
42 |   static_assert(noexcept(swl::bad_variant_access{"hello"}.what()), "must be noexcept");
43 |   swl::bad_variant_access ex;
44 |   SWL_ASSERT(ex.what());
45 | 
46 |   SWL_END_TEST_SIGNAL 
47 |  return 0; 
48 | 
49 | }
50 | 


--------------------------------------------------------------------------------
/tests/tests/variant.get/get_if_index.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // <variant>
 13 | 
 14 | // template <size_t I, class... Types>
 15 | //  constexpr add_pointer_t<variant_alternative_t<I, variant<Types...>>>
 16 | //   get_if(variant<Types...>* v) noexcept;
 17 | // template <size_t I, class... Types>
 18 | //  constexpr add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
 19 | //   get_if(const variant<Types...>* v) noexcept;
 20 | 
 21 | #include <swl_assert.hpp> 
 22 | #include <swl/variant.hpp> 
 23 | 
 24 | #include "test_macros.h"
 25 | #include "variant_test_helpers.h"
 26 | 
 27 |  
 28 | #include <memory>
 29 | 
 30 | void test_const_get_if() {
 31 |   {
 32 |     using V = swl::variant<int>;
 33 |     constexpr const V *v = nullptr;
 34 |     static_assert(swl::get_if<0>(v) == nullptr, "");
 35 |   }
 36 |   {
 37 |     using V = swl::variant<int, const long>;
 38 |     constexpr V v(42);
 39 |     ASSERT_NOEXCEPT(swl::get_if<0>(&v));
 40 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), const int *);
 41 |     static_assert(*swl::get_if<0>(&v) == 42, "");
 42 |     static_assert(swl::get_if<1>(&v) == nullptr, "");
 43 |   }
 44 |   {
 45 |     using V = swl::variant<int, const long>;
 46 |     constexpr V v(42l);
 47 |     ASSERT_SAME_TYPE(decltype(swl::get_if<1>(&v)), const long *);
 48 |     static_assert(*swl::get_if<1>(&v) == 42, "");
 49 |     static_assert(swl::get_if<0>(&v) == nullptr, "");
 50 |   }
 51 | // FIXME: Remove these once reference support is reinstated
 52 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 53 |   {
 54 |     using V = swl::variant<int &>;
 55 |     int x = 42;
 56 |     const V v(x);
 57 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), int *);
 58 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
 59 |   }
 60 |   {
 61 |     using V = swl::variant<int &&>;
 62 |     int x = 42;
 63 |     const V v(std::move(x));
 64 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), int *);
 65 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
 66 |   }
 67 |   {
 68 |     using V = swl::variant<const int &&>;
 69 |     int x = 42;
 70 |     const V v(std::move(x));
 71 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), const int *);
 72 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
 73 |   }
 74 | #endif
 75 | }
 76 | 
 77 | void test_get_if() {
 78 |   {
 79 |     using V = swl::variant<int>;
 80 |     V *v = nullptr;
 81 |     SWL_ASSERT(swl::get_if<0>(v) == nullptr);
 82 |   }
 83 |   {
 84 |     using V = swl::variant<int, long>;
 85 |     V v(42);
 86 |     ASSERT_NOEXCEPT(swl::get_if<0>(&v));
 87 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), int *);
 88 |     SWL_ASSERT(*swl::get_if<0>(&v) == 42);
 89 |     SWL_ASSERT(swl::get_if<1>(&v) == nullptr);
 90 |   }
 91 |   {
 92 |     using V = swl::variant<int, const long>;
 93 |     V v(42l);
 94 |     ASSERT_SAME_TYPE(decltype(swl::get_if<1>(&v)), const long *);
 95 |     SWL_ASSERT(*swl::get_if<1>(&v) == 42);
 96 |     SWL_ASSERT(swl::get_if<0>(&v) == nullptr);
 97 |   }
 98 | // FIXME: Remove these once reference support is reinstated
 99 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
100 |   {
101 |     using V = swl::variant<int &>;
102 |     int x = 42;
103 |     V v(x);
104 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), int *);
105 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
106 |   }
107 |   {
108 |     using V = swl::variant<const int &>;
109 |     int x = 42;
110 |     V v(x);
111 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), const int *);
112 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
113 |   }
114 |   {
115 |     using V = swl::variant<int &&>;
116 |     int x = 42;
117 |     V v(std::move(x));
118 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), int *);
119 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
120 |   }
121 |   {
122 |     using V = swl::variant<const int &&>;
123 |     int x = 42;
124 |     V v(std::move(x));
125 |     ASSERT_SAME_TYPE(decltype(swl::get_if<0>(&v)), const int *);
126 |     SWL_ASSERT(swl::get_if<0>(&v) == &x);
127 |   }
128 | #endif
129 | }
130 | 
131 | int main(int, char**) {
132 |   test_const_get_if();
133 |   test_get_if();
134 | 
135 |   SWL_END_TEST_SIGNAL 
136 |  return 0; 
137 | 
138 | }
139 | 


--------------------------------------------------------------------------------
/tests/tests/variant.get/get_if_type.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // <variant>
 13 | 
 14 | //  template <class T, class... Types>
 15 | //  constexpr add_pointer_t<T> get_if(variant<Types...>* v) noexcept;
 16 | // template <class T, class... Types>
 17 | //  constexpr add_pointer_t<const T> get_if(const variant<Types...>* v)
 18 | //  noexcept;
 19 | 
 20 | #include <swl_assert.hpp> 
 21 | #include <swl/variant.hpp> 
 22 | 
 23 | #include "test_macros.h"
 24 | #include "variant_test_helpers.h"
 25 |  
 26 | 
 27 | void test_const_get_if() {
 28 |   {
 29 |     using V = swl::variant<int>;
 30 |     constexpr const V *v = nullptr;
 31 |     static_assert(swl::get_if<int>(v) == nullptr, "");
 32 |   }
 33 |   {
 34 |     using V = swl::variant<int, const long>;
 35 |     constexpr V v(42);
 36 |     ASSERT_NOEXCEPT(swl::get_if<int>(&v));
 37 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int>(&v)), const int *);
 38 |     static_assert(*swl::get_if<int>(&v) == 42, "");
 39 |     static_assert(swl::get_if<const long>(&v) == nullptr, "");
 40 |   }
 41 |   {
 42 |     using V = swl::variant<int, const long>;
 43 |     constexpr V v(42l);
 44 |     ASSERT_SAME_TYPE(decltype(swl::get_if<const long>(&v)), const long *);
 45 |     static_assert(*swl::get_if<const long>(&v) == 42, "");
 46 |     static_assert(swl::get_if<int>(&v) == nullptr, "");
 47 |   }
 48 | // FIXME: Remove these once reference support is reinstated
 49 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 50 |   {
 51 |     using V = swl::variant<int &>;
 52 |     int x = 42;
 53 |     const V v(x);
 54 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int &>(&v)), int *);
 55 |     SWL_ASSERT(swl::get_if<int &>(&v) == &x);
 56 |   }
 57 |   {
 58 |     using V = swl::variant<int &&>;
 59 |     int x = 42;
 60 |     const V v(std::move(x));
 61 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int &&>(&v)), int *);
 62 |     SWL_ASSERT(swl::get_if<int &&>(&v) == &x);
 63 |   }
 64 |   {
 65 |     using V = swl::variant<const int &&>;
 66 |     int x = 42;
 67 |     const V v(std::move(x));
 68 |     ASSERT_SAME_TYPE(decltype(swl::get_if<const int &&>(&v)), const int *);
 69 |     SWL_ASSERT(swl::get_if<const int &&>(&v) == &x);
 70 |   }
 71 | #endif
 72 | }
 73 | 
 74 | void test_get_if() {
 75 |   {
 76 |     using V = swl::variant<int>;
 77 |     V *v = nullptr;
 78 |     SWL_ASSERT(swl::get_if<int>(v) == nullptr);
 79 |   }
 80 |   {
 81 |     using V = swl::variant<int, const long>;
 82 |     V v(42);
 83 |     ASSERT_NOEXCEPT(swl::get_if<int>(&v));
 84 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int>(&v)), int *);
 85 |     SWL_ASSERT(*swl::get_if<int>(&v) == 42);
 86 |     SWL_ASSERT(swl::get_if<const long>(&v) == nullptr);
 87 |   }
 88 |   {
 89 |     using V = swl::variant<int, const long>;
 90 |     V v(42l);
 91 |     ASSERT_SAME_TYPE(decltype(swl::get_if<const long>(&v)), const long *);
 92 |     SWL_ASSERT(*swl::get_if<const long>(&v) == 42);
 93 |     SWL_ASSERT(swl::get_if<int>(&v) == nullptr);
 94 |   }
 95 | // FIXME: Remove these once reference support is reinstated
 96 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 97 |   {
 98 |     using V = swl::variant<int &>;
 99 |     int x = 42;
100 |     V v(x);
101 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int &>(&v)), int *);
102 |     SWL_ASSERT(swl::get_if<int &>(&v) == &x);
103 |   }
104 |   {
105 |     using V = swl::variant<const int &>;
106 |     int x = 42;
107 |     V v(x);
108 |     ASSERT_SAME_TYPE(decltype(swl::get_if<const int &>(&v)), const int *);
109 |     SWL_ASSERT(swl::get_if<const int &>(&v) == &x);
110 |   }
111 |   {
112 |     using V = swl::variant<int &&>;
113 |     int x = 42;
114 |     V v(std::move(x));
115 |     ASSERT_SAME_TYPE(decltype(swl::get_if<int &&>(&v)), int *);
116 |     SWL_ASSERT(swl::get_if<int &&>(&v) == &x);
117 |   }
118 |   {
119 |     using V = swl::variant<const int &&>;
120 |     int x = 42;
121 |     V v(std::move(x));
122 |     ASSERT_SAME_TYPE(decltype(swl::get_if<const int &&>(&v)), const int *);
123 |     SWL_ASSERT(swl::get_if<const int &&>(&v) == &x);
124 |   }
125 | #endif
126 | }
127 | 
128 | int main(int, char**) {
129 |   test_const_get_if();
130 |   test_get_if();
131 | 
132 |   SWL_END_TEST_SIGNAL 
133 |  return 0; 
134 | 
135 | }
136 | 


--------------------------------------------------------------------------------
/tests/tests/variant.get/get_index.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <size_t I, class... Types>
 21 | //   constexpr variant_alternative_t<I, variant<Types...>>&
 22 | //   get(variant<Types...>& v);
 23 | // template <size_t I, class... Types>
 24 | //   constexpr variant_alternative_t<I, variant<Types...>>&&
 25 | //   get(variant<Types...>&& v);
 26 | // template <size_t I, class... Types>
 27 | //   constexpr variant_alternative_t<I, variant<Types...>> const& get(const
 28 | //   variant<Types...>& v);
 29 | // template <size_t I, class... Types>
 30 | //  constexpr variant_alternative_t<I, variant<Types...>> const&& get(const
 31 | //  variant<Types...>&& v);
 32 | 
 33 | #include "test_macros.h"
 34 | #include "test_workarounds.h"
 35 | #include "variant_test_helpers.h"
 36 |  
 37 | #include <type_traits>
 38 | #include <utility>
 39 | 
 40 | #include <swl_assert.hpp> 
 41 | #include <swl/variant.hpp> 
 42 | 
 43 | void test_const_lvalue_get() {
 44 |   {
 45 |     using V = swl::variant<int, const long>;
 46 |     constexpr V v(42);
 47 | #ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
 48 |     ASSERT_NOEXCEPT(swl::get<0>(v));
 49 | #else
 50 |     ASSERT_NOT_NOEXCEPT(swl::get<0>(v));
 51 | #endif
 52 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), const int &);
 53 |     static_assert(swl::get<0>(v) == 42, "");
 54 |   }
 55 |   {
 56 |     using V = swl::variant<int, const long>;
 57 |     const V v(42);
 58 |     ASSERT_NOT_NOEXCEPT(swl::get<0>(v));
 59 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), const int &);
 60 |     SWL_ASSERT(swl::get<0>(v) == 42);
 61 |   }
 62 |   {
 63 |     using V = swl::variant<int, const long>;
 64 |     constexpr V v(42l);
 65 | #ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
 66 |     ASSERT_NOEXCEPT(swl::get<1>(v));
 67 | #else
 68 |     ASSERT_NOT_NOEXCEPT(swl::get<1>(v));
 69 | #endif
 70 |     ASSERT_SAME_TYPE(decltype(swl::get<1>(v)), const long &);
 71 |     static_assert(swl::get<1>(v) == 42, "");
 72 |   }
 73 |   {
 74 |     using V = swl::variant<int, const long>;
 75 |     const V v(42l);
 76 |     ASSERT_NOT_NOEXCEPT(swl::get<1>(v));
 77 |     ASSERT_SAME_TYPE(decltype(swl::get<1>(v)), const long &);
 78 |     SWL_ASSERT(swl::get<1>(v) == 42);
 79 |   }
 80 | // FIXME: Remove these once reference support is reinstated
 81 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 82 |   {
 83 |     using V = swl::variant<int &>;
 84 |     int x = 42;
 85 |     const V v(x);
 86 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), int &);
 87 |     SWL_ASSERT(&swl::get<0>(v) == &x);
 88 |   }
 89 |   {
 90 |     using V = swl::variant<int &&>;
 91 |     int x = 42;
 92 |     const V v(std::move(x));
 93 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), int &);
 94 |     SWL_ASSERT(&swl::get<0>(v) == &x);
 95 |   }
 96 |   {
 97 |     using V = swl::variant<const int &&>;
 98 |     int x = 42;
 99 |     const V v(std::move(x));
100 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), const int &);
101 |     SWL_ASSERT(&swl::get<0>(v) == &x);
102 |   }
103 | #endif
104 | }
105 | 
106 | void test_lvalue_get() {
107 |   {
108 |     using V = swl::variant<int, const long>;
109 |     V v(42);
110 |     ASSERT_NOT_NOEXCEPT(swl::get<0>(v));
111 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), int &);
112 |     SWL_ASSERT(swl::get<0>(v) == 42);
113 |   }
114 |   {
115 |     using V = swl::variant<int, const long>;
116 |     V v(42l);
117 |     ASSERT_SAME_TYPE(decltype(swl::get<1>(v)), const long &);
118 |     SWL_ASSERT(swl::get<1>(v) == 42);
119 |   }
120 | // FIXME: Remove these once reference support is reinstated
121 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
122 |   {
123 |     using V = swl::variant<int &>;
124 |     int x = 42;
125 |     V v(x);
126 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), int &);
127 |     SWL_ASSERT(&swl::get<0>(v) == &x);
128 |   }
129 |   {
130 |     using V = swl::variant<const int &>;
131 |     int x = 42;
132 |     V v(x);
133 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), const int &);
134 |     SWL_ASSERT(&swl::get<0>(v) == &x);
135 |   }
136 |   {
137 |     using V = swl::variant<int &&>;
138 |     int x = 42;
139 |     V v(std::move(x));
140 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), int &);
141 |     SWL_ASSERT(&swl::get<0>(v) == &x);
142 |   }
143 |   {
144 |     using V = swl::variant<const int &&>;
145 |     int x = 42;
146 |     V v(std::move(x));
147 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(v)), const int &);
148 |     SWL_ASSERT(&swl::get<0>(v) == &x);
149 |   }
150 | #endif
151 | }
152 | 
153 | void test_rvalue_get() {
154 |   {
155 |     using V = swl::variant<int, const long>;
156 |     V v(42);
157 |     ASSERT_NOT_NOEXCEPT(swl::get<0>(std::move(v)));
158 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), int &&);
159 |     SWL_ASSERT(swl::get<0>(std::move(v)) == 42);
160 |   }
161 |   {
162 |     using V = swl::variant<int, const long>;
163 |     V v(42l);
164 |     ASSERT_SAME_TYPE(decltype(swl::get<1>(std::move(v))), const long &&);
165 |     SWL_ASSERT(swl::get<1>(std::move(v)) == 42);
166 |   }
167 | // FIXME: Remove these once reference support is reinstated
168 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
169 |   {
170 |     using V = swl::variant<int &>;
171 |     int x = 42;
172 |     V v(x);
173 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), int &);
174 |     SWL_ASSERT(&swl::get<0>(std::move(v)) == &x);
175 |   }
176 |   {
177 |     using V = swl::variant<const int &>;
178 |     int x = 42;
179 |     V v(x);
180 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), const int &);
181 |     SWL_ASSERT(&swl::get<0>(std::move(v)) == &x);
182 |   }
183 |   {
184 |     using V = swl::variant<int &&>;
185 |     int x = 42;
186 |     V v(std::move(x));
187 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), int &&);
188 |     int &&xref = swl::get<0>(std::move(v));
189 |     SWL_ASSERT(&xref == &x);
190 |   }
191 |   {
192 |     using V = swl::variant<const int &&>;
193 |     int x = 42;
194 |     V v(std::move(x));
195 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), const int &&);
196 |     const int &&xref = swl::get<0>(std::move(v));
197 |     SWL_ASSERT(&xref == &x);
198 |   }
199 | #endif
200 | }
201 | 
202 | void test_const_rvalue_get() {
203 |   {
204 |     using V = swl::variant<int, const long>;
205 |     const V v(42);
206 |     ASSERT_NOT_NOEXCEPT(swl::get<0>(std::move(v)));
207 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), const int &&);
208 |     SWL_ASSERT(swl::get<0>(std::move(v)) == 42);
209 |   }
210 |   {
211 |     using V = swl::variant<int, const long>;
212 |     const V v(42l);
213 |     ASSERT_SAME_TYPE(decltype(swl::get<1>(std::move(v))), const long &&);
214 |     SWL_ASSERT(swl::get<1>(std::move(v)) == 42);
215 |   }
216 | // FIXME: Remove these once reference support is reinstated
217 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
218 |   {
219 |     using V = swl::variant<int &>;
220 |     int x = 42;
221 |     const V v(x);
222 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), int &);
223 |     SWL_ASSERT(&swl::get<0>(std::move(v)) == &x);
224 |   }
225 |   {
226 |     using V = swl::variant<const int &>;
227 |     int x = 42;
228 |     const V v(x);
229 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), const int &);
230 |     SWL_ASSERT(&swl::get<0>(std::move(v)) == &x);
231 |   }
232 |   {
233 |     using V = swl::variant<int &&>;
234 |     int x = 42;
235 |     const V v(std::move(x));
236 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), int &&);
237 |     int &&xref = swl::get<0>(std::move(v));
238 |     SWL_ASSERT(&xref == &x);
239 |   }
240 |   {
241 |     using V = swl::variant<const int &&>;
242 |     int x = 42;
243 |     const V v(std::move(x));
244 |     ASSERT_SAME_TYPE(decltype(swl::get<0>(std::move(v))), const int &&);
245 |     const int &&xref = swl::get<0>(std::move(v));
246 |     SWL_ASSERT(&xref == &x);
247 |   }
248 | #endif
249 | }
250 | 
251 | template <std::size_t I> using Idx = std::integral_constant<size_t, I>;
252 | 
253 | void test_throws_for_all_value_categories() {
254 | #ifndef TEST_HAS_NO_EXCEPTIONS
255 |   using V = swl::variant<int, long>;
256 |   V v0(42);
257 |   const V &cv0 = v0;
258 |   SWL_ASSERT(v0.index() == 0);
259 |   V v1(42l);
260 |   const V &cv1 = v1;
261 |   SWL_ASSERT(v1.index() == 1);
262 |   std::integral_constant<size_t, 0> zero;
263 |   std::integral_constant<size_t, 1> one;
264 |   auto test = [](auto idx, auto &&v) {
265 |     using Idx = decltype(idx);
266 |     try {
267 |       TEST_IGNORE_NODISCARD swl::get<Idx::value>(std::forward<decltype(v)>(v));
268 |     } catch (const swl::bad_variant_access &) {
269 |       return true;
270 |     } catch (...) { /* ... */
271 |     }
272 |     return false;
273 |   };
274 |   { // lvalue test cases
275 |     SWL_ASSERT(test(one, v0));
276 |     SWL_ASSERT(test(zero, v1));
277 |   }
278 |   { // const lvalue test cases
279 |     SWL_ASSERT(test(one, cv0));
280 |     SWL_ASSERT(test(zero, cv1));
281 |   }
282 |   { // rvalue test cases
283 |     SWL_ASSERT(test(one, std::move(v0)));
284 |     SWL_ASSERT(test(zero, std::move(v1)));
285 |   }
286 |   { // const rvalue test cases
287 |     SWL_ASSERT(test(one, std::move(cv0)));
288 |     SWL_ASSERT(test(zero, std::move(cv1)));
289 |   }
290 | #endif
291 | }
292 | 
293 | int main(int, char**) {
294 |   test_const_lvalue_get();
295 |   test_lvalue_get();
296 |   test_rvalue_get();
297 |   test_const_rvalue_get();
298 |   test_throws_for_all_value_categories();
299 | 
300 |   SWL_END_TEST_SIGNAL 
301 |  return 0; 
302 | 
303 | }
304 | 


--------------------------------------------------------------------------------
/tests/tests/variant.get/get_type.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class T, class... Types> constexpr T& get(variant<Types...>& v);
 21 | // template <class T, class... Types> constexpr T&& get(variant<Types...>&& v);
 22 | // template <class T, class... Types> constexpr const T& get(const
 23 | // variant<Types...>& v);
 24 | // template <class T, class... Types> constexpr const T&& get(const
 25 | // variant<Types...>&& v);
 26 | 
 27 | #include "test_macros.h"
 28 | #include "test_workarounds.h"
 29 | #include "variant_test_helpers.h"
 30 |  
 31 | #include <type_traits>
 32 | #include <utility>
 33 | #include <swl_assert.hpp> 
 34 | #include <swl/variant.hpp> 
 35 | 
 36 | void test_const_lvalue_get() {
 37 |   {
 38 |     using V = swl::variant<int, const long>;
 39 |     constexpr V v(42);
 40 | #ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
 41 |     ASSERT_NOEXCEPT(swl::get<int>(v));
 42 | #else
 43 |     ASSERT_NOT_NOEXCEPT(swl::get<int>(v));
 44 | #endif
 45 |     ASSERT_SAME_TYPE(decltype(swl::get<int>(v)), const int &);
 46 |     static_assert(swl::get<int>(v) == 42, "");
 47 |   }
 48 |   {
 49 |     using V = swl::variant<int, const long>;
 50 |     const V v(42);
 51 |     ASSERT_NOT_NOEXCEPT(swl::get<int>(v));
 52 |     ASSERT_SAME_TYPE(decltype(swl::get<int>(v)), const int &);
 53 |     SWL_ASSERT(swl::get<int>(v) == 42);
 54 |   }
 55 |   {
 56 |     using V = swl::variant<int, const long>;
 57 |     constexpr V v(42l);
 58 | #ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
 59 |     ASSERT_NOEXCEPT(swl::get<const long>(v));
 60 | #else
 61 |     ASSERT_NOT_NOEXCEPT(swl::get<const long>(v));
 62 | #endif
 63 |     ASSERT_SAME_TYPE(decltype(swl::get<const long>(v)), const long &);
 64 |     static_assert(swl::get<const long>(v) == 42, "");
 65 |   }
 66 |   {
 67 |     using V = swl::variant<int, const long>;
 68 |     const V v(42l);
 69 |     ASSERT_NOT_NOEXCEPT(swl::get<const long>(v));
 70 |     ASSERT_SAME_TYPE(decltype(swl::get<const long>(v)), const long &);
 71 |     SWL_ASSERT(swl::get<const long>(v) == 42);
 72 |   }
 73 | // FIXME: Remove these once reference support is reinstated
 74 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 75 |   {
 76 |     using V = swl::variant<int &>;
 77 |     int x = 42;
 78 |     const V v(x);
 79 |     ASSERT_SAME_TYPE(decltype(swl::get<int &>(v)), int &);
 80 |     SWL_ASSERT(&swl::get<int &>(v) == &x);
 81 |   }
 82 |   {
 83 |     using V = swl::variant<int &&>;
 84 |     int x = 42;
 85 |     const V v(std::move(x));
 86 |     ASSERT_SAME_TYPE(decltype(swl::get<int &&>(v)), int &);
 87 |     SWL_ASSERT(&swl::get<int &&>(v) == &x);
 88 |   }
 89 |   {
 90 |     using V = swl::variant<const int &&>;
 91 |     int x = 42;
 92 |     const V v(std::move(x));
 93 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &&>(v)), const int &);
 94 |     SWL_ASSERT(&swl::get<const int &&>(v) == &x);
 95 |   }
 96 | #endif
 97 | }
 98 | 
 99 | void test_lvalue_get() {
100 |   {
101 |     using V = swl::variant<int, const long>;
102 |     V v(42);
103 |     ASSERT_NOT_NOEXCEPT(swl::get<int>(v));
104 |     ASSERT_SAME_TYPE(decltype(swl::get<int>(v)), int &);
105 |     SWL_ASSERT(swl::get<int>(v) == 42);
106 |   }
107 |   {
108 |     using V = swl::variant<int, const long>;
109 |     V v(42l);
110 |     ASSERT_SAME_TYPE(decltype(swl::get<const long>(v)), const long &);
111 |     SWL_ASSERT(swl::get<const long>(v) == 42);
112 |   }
113 | // FIXME: Remove these once reference support is reinstated
114 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
115 |   {
116 |     using V = swl::variant<int &>;
117 |     int x = 42;
118 |     V v(x);
119 |     ASSERT_SAME_TYPE(decltype(swl::get<int &>(v)), int &);
120 |     SWL_ASSERT(&swl::get<int &>(v) == &x);
121 |   }
122 |   {
123 |     using V = swl::variant<const int &>;
124 |     int x = 42;
125 |     V v(x);
126 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &>(v)), const int &);
127 |     SWL_ASSERT(&swl::get<const int &>(v) == &x);
128 |   }
129 |   {
130 |     using V = swl::variant<int &&>;
131 |     int x = 42;
132 |     V v(std::move(x));
133 |     ASSERT_SAME_TYPE(decltype(swl::get<int &&>(v)), int &);
134 |     SWL_ASSERT(&swl::get<int &&>(v) == &x);
135 |   }
136 |   {
137 |     using V = swl::variant<const int &&>;
138 |     int x = 42;
139 |     V v(std::move(x));
140 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &&>(v)), const int &);
141 |     SWL_ASSERT(&swl::get<const int &&>(v) == &x);
142 |   }
143 | #endif
144 | }
145 | 
146 | void test_rvalue_get() {
147 |   {
148 |     using V = swl::variant<int, const long>;
149 |     V v(42);
150 |     ASSERT_NOT_NOEXCEPT(swl::get<int>(std::move(v)));
151 |     ASSERT_SAME_TYPE(decltype(swl::get<int>(std::move(v))), int &&);
152 |     SWL_ASSERT(swl::get<int>(std::move(v)) == 42);
153 |   }
154 |   {
155 |     using V = swl::variant<int, const long>;
156 |     V v(42l);
157 |     ASSERT_SAME_TYPE(decltype(swl::get<const long>(std::move(v))),
158 |                      const long &&);
159 |     SWL_ASSERT(swl::get<const long>(std::move(v)) == 42);
160 |   }
161 | // FIXME: Remove these once reference support is reinstated
162 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
163 |   {
164 |     using V = swl::variant<int &>;
165 |     int x = 42;
166 |     V v(x);
167 |     ASSERT_SAME_TYPE(decltype(swl::get<int &>(std::move(v))), int &);
168 |     SWL_ASSERT(&swl::get<int &>(std::move(v)) == &x);
169 |   }
170 |   {
171 |     using V = swl::variant<const int &>;
172 |     int x = 42;
173 |     V v(x);
174 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &>(std::move(v))),
175 |                      const int &);
176 |     SWL_ASSERT(&swl::get<const int &>(std::move(v)) == &x);
177 |   }
178 |   {
179 |     using V = swl::variant<int &&>;
180 |     int x = 42;
181 |     V v(std::move(x));
182 |     ASSERT_SAME_TYPE(decltype(swl::get<int &&>(std::move(v))), int &&);
183 |     int &&xref = swl::get<int &&>(std::move(v));
184 |     SWL_ASSERT(&xref == &x);
185 |   }
186 |   {
187 |     using V = swl::variant<const int &&>;
188 |     int x = 42;
189 |     V v(std::move(x));
190 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &&>(std::move(v))),
191 |                      const int &&);
192 |     const int &&xref = swl::get<const int &&>(std::move(v));
193 |     SWL_ASSERT(&xref == &x);
194 |   }
195 | #endif
196 | }
197 | 
198 | void test_const_rvalue_get() {
199 |   {
200 |     using V = swl::variant<int, const long>;
201 |     const V v(42);
202 |     ASSERT_NOT_NOEXCEPT(swl::get<int>(std::move(v)));
203 |     ASSERT_SAME_TYPE(decltype(swl::get<int>(std::move(v))), const int &&);
204 |     SWL_ASSERT(swl::get<int>(std::move(v)) == 42);
205 |   }
206 |   {
207 |     using V = swl::variant<int, const long>;
208 |     const V v(42l);
209 |     ASSERT_SAME_TYPE(decltype(swl::get<const long>(std::move(v))),
210 |                      const long &&);
211 |     SWL_ASSERT(swl::get<const long>(std::move(v)) == 42);
212 |   }
213 | // FIXME: Remove these once reference support is reinstated
214 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
215 |   {
216 |     using V = swl::variant<int &>;
217 |     int x = 42;
218 |     const V v(x);
219 |     ASSERT_SAME_TYPE(decltype(swl::get<int &>(std::move(v))), int &);
220 |     SWL_ASSERT(&swl::get<int &>(std::move(v)) == &x);
221 |   }
222 |   {
223 |     using V = swl::variant<const int &>;
224 |     int x = 42;
225 |     const V v(x);
226 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &>(std::move(v))),
227 |                      const int &);
228 |     SWL_ASSERT(&swl::get<const int &>(std::move(v)) == &x);
229 |   }
230 |   {
231 |     using V = swl::variant<int &&>;
232 |     int x = 42;
233 |     const V v(std::move(x));
234 |     ASSERT_SAME_TYPE(decltype(swl::get<int &&>(std::move(v))), int &&);
235 |     int &&xref = swl::get<int &&>(std::move(v));
236 |     SWL_ASSERT(&xref == &x);
237 |   }
238 |   {
239 |     using V = swl::variant<const int &&>;
240 |     int x = 42;
241 |     const V v(std::move(x));
242 |     ASSERT_SAME_TYPE(decltype(swl::get<const int &&>(std::move(v))),
243 |                      const int &&);
244 |     const int &&xref = swl::get<const int &&>(std::move(v));
245 |     SWL_ASSERT(&xref == &x);
246 |   }
247 | #endif
248 | }
249 | 
250 | template <class Tp> struct identity { using type = Tp; };
251 | 
252 | void test_throws_for_all_value_categories() {
253 | #ifndef TEST_HAS_NO_EXCEPTIONS
254 |   using V = swl::variant<int, long>;
255 |   V v0(42);
256 |   const V &cv0 = v0;
257 |   SWL_ASSERT(v0.index() == 0);
258 |   V v1(42l);
259 |   const V &cv1 = v1;
260 |   SWL_ASSERT(v1.index() == 1);
261 |   identity<int> zero;
262 |   identity<long> one;
263 |   auto test = [](auto idx, auto &&v) {
264 |     using Idx = decltype(idx);
265 |     try {
266 |       TEST_IGNORE_NODISCARD swl::get<typename Idx::type>(std::forward<decltype(v)>(v));
267 |     } catch (const swl::bad_variant_access &) {
268 |       return true;
269 |     } catch (...) { /* ... */
270 |     }
271 |     return false;
272 |   };
273 |   { // lvalue test cases
274 |     SWL_ASSERT(test(one, v0));
275 |     SWL_ASSERT(test(zero, v1));
276 |   }
277 |   { // const lvalue test cases
278 |     SWL_ASSERT(test(one, cv0));
279 |     SWL_ASSERT(test(zero, cv1));
280 |   }
281 |   { // rvalue test cases
282 |     SWL_ASSERT(test(one, std::move(v0)));
283 |     SWL_ASSERT(test(zero, std::move(v1)));
284 |   }
285 |   { // const rvalue test cases
286 |     SWL_ASSERT(test(one, std::move(cv0)));
287 |     SWL_ASSERT(test(zero, std::move(cv1)));
288 |   }
289 | #endif
290 | }
291 | 
292 | int main(int, char**) {
293 |   test_const_lvalue_get();
294 |   test_lvalue_get();
295 |   test_rvalue_get();
296 |   test_const_rvalue_get();
297 |   test_throws_for_all_value_categories();
298 | 
299 |   SWL_END_TEST_SIGNAL 
300 |  return 0; 
301 | 
302 | }
303 | 


--------------------------------------------------------------------------------
/tests/tests/variant.get/holds_alternative.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class T, class... Types>
15 | // constexpr bool holds_alternative(const variant<Types...>& v) noexcept;
16 | 
17 | #include "test_macros.h"
18 | #include <swl_assert.hpp> 
19 | #include <swl/variant.hpp> 
20 |  
21 | 
22 | int main(int, char**) {
23 |   {
24 |     using V = swl::variant<int>;
25 |     constexpr V v;
26 |     static_assert(swl::holds_alternative<int>(v), "");
27 |   }
28 |   {
29 |     using V = swl::variant<int, long>;
30 |     constexpr V v;
31 |     static_assert(swl::holds_alternative<int>(v), "");
32 |     static_assert(!swl::holds_alternative<long>(v), "");
33 |   }
34 |   { // noexcept test
35 |     using V = swl::variant<int>;
36 |     const V v;
37 |     ASSERT_NOEXCEPT(swl::holds_alternative<int>(v));
38 |   }
39 | 
40 |   SWL_END_TEST_SIGNAL 
41 |  return 0; 
42 | 
43 | }
44 | 


--------------------------------------------------------------------------------
/tests/tests/variant.hash/enabled_hash.pass.cpp.ignore:
--------------------------------------------------------------------------------
 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 | // Test that <variant> provides all of the arithmetic, enum, and pointer
14 | // hash specializations.
15 | 
16 | #include <swl_assert.hpp> 
17 | #include <swl/variant.hpp> 
18 |  
19 | 
20 | #include "poisoned_hash_helper.h"
21 | 
22 | #include "test_macros.h"
23 | 
24 | int main(int, char**) {
25 |   
26 |   // this merely check if <functional> was included? disabling it for now
27 |   test_library_hash_specializations_available();
28 | 
29 |   SWL_END_TEST_SIGNAL 
30 |  return 0; 
31 | 
32 | }
33 | 


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


--------------------------------------------------------------------------------
/tests/tests/variant.helpers/variant_alternative.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <size_t I, class T> struct variant_alternative; // undefined
15 | // template <size_t I, class T> struct variant_alternative<I, const T>;
16 | // template <size_t I, class T> struct variant_alternative<I, volatile T>;
17 | // template <size_t I, class T> struct variant_alternative<I, const volatile T>;
18 | // template <size_t I, class T>
19 | //   using variant_alternative_t = typename variant_alternative<I, T>::type;
20 | //
21 | // template <size_t I, class... Types>
22 | //    struct variant_alternative<I, variant<Types...>>;
23 | 
24 | #include <memory>
25 | #include <type_traits>
26 | #include <swl/variant.hpp>
27 | 
28 | int main(int, char**) {
29 |     using V = swl::variant<int, void *, const void *, long double>;
30 |     swl::variant_alternative<4, V>::type foo;  // expected-error@variant:* {{Index out of bounds in std::variant_alternative<>}}
31 | 
32 |   return 0;
33 | }
34 | 


--------------------------------------------------------------------------------
/tests/tests/variant.helpers/variant_alternative.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <size_t I, class T> struct variant_alternative; // undefined
15 | // template <size_t I, class T> struct variant_alternative<I, const T>;
16 | // template <size_t I, class T> struct variant_alternative<I, volatile T>;
17 | // template <size_t I, class T> struct variant_alternative<I, const volatile T>;
18 | // template <size_t I, class T>
19 | //   using variant_alternative_t = typename variant_alternative<I, T>::type;
20 | //
21 | // template <size_t I, class... Types>
22 | //    struct variant_alternative<I, variant<Types...>>;
23 | 
24 | #include <memory>
25 | #include <type_traits>
26 | #include <swl/variant.hpp>
27 | 
28 | #include "test_macros.h"
29 | #include "variant_test_helpers.h"
30 | 
31 | template <class V, size_t I, class E> void test() {
32 |   static_assert(
33 |       std::is_same_v<typename swl::variant_alternative<I, V>::type, E>, "");
34 |   static_assert(
35 |       std::is_same_v<typename swl::variant_alternative<I, const V>::type,
36 |                      const E>,
37 |       "");
38 |   static_assert(
39 |       std::is_same_v<typename swl::variant_alternative<I, volatile V>::type,
40 |                      volatile E>,
41 |       "");
42 |   static_assert(
43 |       std::is_same_v<
44 |           typename swl::variant_alternative<I, const volatile V>::type,
45 |           const volatile E>,
46 |       "");
47 |   static_assert(std::is_same_v<swl::variant_alternative_t<I, V>, E>, "");
48 |   static_assert(std::is_same_v<swl::variant_alternative_t<I, const V>, const E>,
49 |                 "");
50 |   static_assert(
51 |       std::is_same_v<swl::variant_alternative_t<I, volatile V>, volatile E>,
52 |       "");
53 |   static_assert(std::is_same_v<swl::variant_alternative_t<I, const volatile V>,
54 |                                const volatile E>,
55 |                 "");
56 | }
57 | 
58 | int main(int, char**) {
59 |   {
60 |     using V = swl::variant<int, void *, const void *, long double>;
61 |     test<V, 0, int>();
62 |     test<V, 1, void *>();
63 |     test<V, 2, const void *>();
64 |     test<V, 3, long double>();
65 |   }
66 |   
67 | /* 
68 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
69 |   {
70 |     using V = swl::variant<int, int &, const int &, int &&, long double>;
71 |     test<V, 0, int>();
72 |     test<V, 1, int &>();
73 |     test<V, 2, const int &>();
74 |     test<V, 3, int &&>();
75 |     test<V, 4, long double>();
76 |   }
77 | #endif
78 | */ 
79 | 
80 |   return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/tests/variant.helpers/variant_size.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class T> struct variant_size; // undefined
15 | // template <class T> struct variant_size<const T>;
16 | // template <class T> struct variant_size<volatile T>;
17 | // template <class T> struct variant_size<const volatile T>;
18 | // template <class T> constexpr size_t variant_size_v
19 | //     = variant_size<T>::value;
20 | 
21 | #include <type_traits>
22 | #include <swl/variant.hpp>
23 | 
24 | #include "test_macros.h"
25 | 
26 | template <class V, size_t E> void test() {
27 |   static_assert(swl::variant_size<V>::value == E, "");
28 |   static_assert(swl::variant_size<const V>::value == E, "");
29 |   static_assert(swl::variant_size<volatile V>::value == E, "");
30 |   static_assert(swl::variant_size<const volatile V>::value == E, "");
31 |   static_assert(swl::variant_size_v<V> == E, "");
32 |   static_assert(swl::variant_size_v<const V> == E, "");
33 |   static_assert(swl::variant_size_v<volatile V> == E, "");
34 |   static_assert(swl::variant_size_v<const volatile V> == E, "");
35 |   static_assert(std::is_base_of<std::integral_constant<std::size_t, E>,
36 |                                 swl::variant_size<V>>::value,
37 |                 "");
38 | };
39 | 
40 | int main(int, char**) {
41 |   
42 |   // SWL : this is ill-formed, why is this in the test suite? 
43 |   // test<swl::variant<>, 0>();
44 |   test<swl::variant<void *>, 1>();
45 |   test<swl::variant<long, long, void *, double>, 4>();
46 | 
47 |   return 0;
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/tests/variant.monostate.relops/relops.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // constexpr bool operator<(monostate, monostate) noexcept { return false; }
15 | // constexpr bool operator>(monostate, monostate) noexcept { return false; }
16 | // constexpr bool operator<=(monostate, monostate) noexcept { return true; }
17 | // constexpr bool operator>=(monostate, monostate) noexcept { return true; }
18 | // constexpr bool operator==(monostate, monostate) noexcept { return true; }
19 | // constexpr bool operator!=(monostate, monostate) noexcept { return false; }
20 | 
21 | #include "test_macros.h"
22 |  
23 | #include <type_traits>
24 | #include <swl_assert.hpp> 
25 | #include <swl/variant.hpp> 
26 | 
27 | int main(int, char**) {
28 |   using M = swl::monostate;
29 |   constexpr M m1{};
30 |   constexpr M m2{};
31 |   {
32 |     static_assert((m1 < m2) == false, "");
33 |     ASSERT_NOEXCEPT(m1 < m2);
34 |   }
35 |   {
36 |     static_assert((m1 > m2) == false, "");
37 |     ASSERT_NOEXCEPT(m1 > m2);
38 |   }
39 |   {
40 |     static_assert((m1 <= m2) == true, "");
41 |     ASSERT_NOEXCEPT(m1 <= m2);
42 |   }
43 |   {
44 |     static_assert((m1 >= m2) == true, "");
45 |     ASSERT_NOEXCEPT(m1 >= m2);
46 |   }
47 |   {
48 |     static_assert((m1 == m2) == true, "");
49 |     ASSERT_NOEXCEPT(m1 == m2);
50 |   }
51 |   {
52 |     static_assert((m1 != m2) == false, "");
53 |     ASSERT_NOEXCEPT(m1 != m2);
54 |   }
55 | 
56 |   SWL_END_TEST_SIGNAL 
57 |  return 0; 
58 | 
59 | }
60 | 


--------------------------------------------------------------------------------
/tests/tests/variant.monostate/monostate.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // struct monostate {};
15 | 
16 | #include <type_traits>
17 | #include <swl_assert.hpp> 
18 | #include <swl/variant.hpp> 
19 | 
20 |  
21 | #include "test_macros.h"
22 | 
23 | int main(int, char**) {
24 |   using M = swl::monostate;
25 |   static_assert(std::is_trivially_default_constructible<M>::value, "");
26 |   static_assert(std::is_trivially_copy_constructible<M>::value, "");
27 |   static_assert(std::is_trivially_copy_assignable<M>::value, "");
28 |   static_assert(std::is_trivially_destructible<M>::value, "");
29 |   constexpr M m{};
30 |   ((void)m);
31 | 
32 |   SWL_END_TEST_SIGNAL 
33 |  return 0; 
34 | 
35 | }
36 | 


--------------------------------------------------------------------------------
/tests/tests/variant.relops/relops.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // <variant>
 13 | 
 14 | // template <class ...Types>
 15 | // constexpr bool
 16 | // operator==(variant<Types...> const&, variant<Types...> const&) noexcept;
 17 | //
 18 | // template <class ...Types>
 19 | // constexpr bool
 20 | // operator!=(variant<Types...> const&, variant<Types...> const&) noexcept;
 21 | //
 22 | // template <class ...Types>
 23 | // constexpr bool
 24 | // operator<(variant<Types...> const&, variant<Types...> const&) noexcept;
 25 | //
 26 | // template <class ...Types>
 27 | // constexpr bool
 28 | // operator>(variant<Types...> const&, variant<Types...> const&) noexcept;
 29 | //
 30 | // template <class ...Types>
 31 | // constexpr bool
 32 | // operator<=(variant<Types...> const&, variant<Types...> const&) noexcept;
 33 | //
 34 | // template <class ...Types>
 35 | // constexpr bool
 36 | // operator>=(variant<Types...> const&, variant<Types...> const&) noexcept;
 37 | 
 38 |  
 39 | #include <type_traits>
 40 | #include <utility>
 41 | 
 42 | #include <swl_assert.hpp> 
 43 | #include <swl/variant.hpp> 
 44 | 
 45 | #include "test_macros.h"
 46 | 
 47 | #ifndef TEST_HAS_NO_EXCEPTIONS
 48 | struct MakeEmptyT {
 49 |   MakeEmptyT() = default;
 50 |   MakeEmptyT(MakeEmptyT &&) { throw 42; }
 51 |   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
 52 | };
 53 | inline bool operator==(const MakeEmptyT &, const MakeEmptyT &) {
 54 |   SWL_ASSERT(false);
 55 |   return false;
 56 | }
 57 | inline bool operator!=(const MakeEmptyT &, const MakeEmptyT &) {
 58 |   SWL_ASSERT(false);
 59 |   return false;
 60 | }
 61 | inline bool operator<(const MakeEmptyT &, const MakeEmptyT &) {
 62 |   SWL_ASSERT(false);
 63 |   return false;
 64 | }
 65 | inline bool operator<=(const MakeEmptyT &, const MakeEmptyT &) {
 66 |   SWL_ASSERT(false);
 67 |   return false;
 68 | }
 69 | inline bool operator>(const MakeEmptyT &, const MakeEmptyT &) {
 70 |   SWL_ASSERT(false);
 71 |   return false;
 72 | }
 73 | inline bool operator>=(const MakeEmptyT &, const MakeEmptyT &) {
 74 |   SWL_ASSERT(false);
 75 |   return false;
 76 | }
 77 | 
 78 | template <class Variant> void makeEmpty(Variant &v) {
 79 |   Variant v2(swl::in_place_type<MakeEmptyT>);
 80 |   try {
 81 |     v = std::move(v2);
 82 |     SWL_ASSERT(false);
 83 |   } catch (...) {
 84 |     SWL_ASSERT(v.valueless_by_exception());
 85 |   }
 86 | }
 87 | #endif // TEST_HAS_NO_EXCEPTIONS
 88 | 
 89 | struct MyBool {
 90 |   bool value;
 91 |   constexpr explicit MyBool(bool v) : value(v) {}
 92 |   constexpr operator bool() const noexcept { return value; }
 93 | };
 94 | 
 95 | struct ComparesToMyBool {
 96 |   int value = 0;
 97 | };
 98 | inline constexpr MyBool operator==(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
 99 |   return MyBool(LHS.value == RHS.value);
100 | }
101 | inline constexpr MyBool operator!=(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
102 |   return MyBool(LHS.value != RHS.value);
103 | }
104 | inline constexpr MyBool operator<(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
105 |   return MyBool(LHS.value < RHS.value);
106 | }
107 | inline constexpr MyBool operator<=(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
108 |   return MyBool(LHS.value <= RHS.value);
109 | }
110 | inline constexpr MyBool operator>(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
111 |   return MyBool(LHS.value > RHS.value);
112 | }
113 | inline constexpr MyBool operator>=(const ComparesToMyBool& LHS, const ComparesToMyBool& RHS) noexcept {
114 |   return MyBool(LHS.value >= RHS.value);
115 | }
116 | 
117 | template <class T1, class T2>
118 | void test_equality_basic() {
119 |   {
120 |     using V = swl::variant<T1, T2>;
121 |     constexpr V v1(swl::in_place_index<0>, T1{42});
122 |     constexpr V v2(swl::in_place_index<0>, T1{42});
123 |     static_assert(v1 == v2, "");
124 |     static_assert(v2 == v1, "");
125 |     static_assert(!(v1 != v2), "");
126 |     static_assert(!(v2 != v1), "");
127 |   }
128 |   {
129 |     using V = swl::variant<T1, T2>;
130 |     constexpr V v1(swl::in_place_index<0>, T1{42});
131 |     constexpr V v2(swl::in_place_index<0>, T1{43});
132 |     static_assert(!(v1 == v2), "");
133 |     static_assert(!(v2 == v1), "");
134 |     static_assert(v1 != v2, "");
135 |     static_assert(v2 != v1, "");
136 |   }
137 |   {
138 |     using V = swl::variant<T1, T2>;
139 |     constexpr V v1(swl::in_place_index<0>, T1{42});
140 |     constexpr V v2(swl::in_place_index<1>, T2{42});
141 |     static_assert(!(v1 == v2), "");
142 |     static_assert(!(v2 == v1), "");
143 |     static_assert(v1 != v2, "");
144 |     static_assert(v2 != v1, "");
145 |   }
146 |   {
147 |     using V = swl::variant<T1, T2>;
148 |     constexpr V v1(swl::in_place_index<1>, T2{42});
149 |     constexpr V v2(swl::in_place_index<1>, T2{42});
150 |     static_assert(v1 == v2, "");
151 |     static_assert(v2 == v1, "");
152 |     static_assert(!(v1 != v2), "");
153 |     static_assert(!(v2 != v1), "");
154 |   }
155 | }
156 | 
157 | void test_equality() {
158 |   test_equality_basic<int, long>();
159 |   test_equality_basic<ComparesToMyBool, int>();
160 |   test_equality_basic<int, ComparesToMyBool>();
161 |   test_equality_basic<ComparesToMyBool, ComparesToMyBool>();
162 | #ifndef TEST_HAS_NO_EXCEPTIONS
163 |   {
164 |     using V = swl::variant<int, MakeEmptyT>;
165 |     V v1;
166 |     V v2;
167 |     makeEmpty(v2);
168 |     SWL_ASSERT(!(v1 == v2));
169 |     SWL_ASSERT(!(v2 == v1));
170 |     SWL_ASSERT(v1 != v2);
171 |     SWL_ASSERT(v2 != v1);
172 |   }
173 |   {
174 |     using V = swl::variant<int, MakeEmptyT>;
175 |     V v1;
176 |     makeEmpty(v1);
177 |     V v2;
178 |     SWL_ASSERT(!(v1 == v2));
179 |     SWL_ASSERT(!(v2 == v1));
180 |     SWL_ASSERT(v1 != v2);
181 |     SWL_ASSERT(v2 != v1);
182 |   }
183 |   {
184 |     using V = swl::variant<int, MakeEmptyT>;
185 |     V v1;
186 |     makeEmpty(v1);
187 |     V v2;
188 |     makeEmpty(v2);
189 |     SWL_ASSERT(v1 == v2);
190 |     SWL_ASSERT(v2 == v1);
191 |     SWL_ASSERT(!(v1 != v2));
192 |     SWL_ASSERT(!(v2 != v1));
193 |   }
194 | #endif
195 | }
196 | 
197 | template <class Var>
198 | constexpr bool test_less(const Var &l, const Var &r, bool expect_less,
199 |                          bool expect_greater) {
200 |   static_assert(std::is_same_v<decltype(l < r), bool>, "");
201 |   static_assert(std::is_same_v<decltype(l <= r), bool>, "");
202 |   static_assert(std::is_same_v<decltype(l > r), bool>, "");
203 |   static_assert(std::is_same_v<decltype(l >= r), bool>, "");
204 | 
205 |   return ((l < r) == expect_less) && (!(l >= r) == expect_less) &&
206 |          ((l > r) == expect_greater) && (!(l <= r) == expect_greater);
207 | }
208 | 
209 | template <class T1, class T2>
210 | void test_relational_basic() {
211 |   { // same index, same value
212 |     using V = swl::variant<T1, T2>;
213 |     constexpr V v1(swl::in_place_index<0>, T1{1});
214 |     constexpr V v2(swl::in_place_index<0>, T1{1});
215 |     static_assert(test_less(v1, v2, false, false), "");
216 |   }
217 |   { // same index, value < other_value
218 |     using V = swl::variant<T1, T2>;
219 |     constexpr V v1(swl::in_place_index<0>, T1{0});
220 |     constexpr V v2(swl::in_place_index<0>, T1{1});
221 |     static_assert(test_less(v1, v2, true, false), "");
222 |   }
223 |   { // same index, value > other_value
224 |     using V = swl::variant<T1, T2>;
225 |     constexpr V v1(swl::in_place_index<0>, T1{1});
226 |     constexpr V v2(swl::in_place_index<0>, T1{0});
227 |     static_assert(test_less(v1, v2, false, true), "");
228 |   }
229 |   { // LHS.index() < RHS.index()
230 |     using V = swl::variant<T1, T2>;
231 |     constexpr V v1(swl::in_place_index<0>, T1{0});
232 |     constexpr V v2(swl::in_place_index<1>, T2{0});
233 |     static_assert(test_less(v1, v2, true, false), "");
234 |   }
235 |   { // LHS.index() > RHS.index()
236 |     using V = swl::variant<T1, T2>;
237 |     constexpr V v1(swl::in_place_index<1>, T2{0});
238 |     constexpr V v2(swl::in_place_index<0>, T1{0});
239 |     static_assert(test_less(v1, v2, false, true), "");
240 |   }
241 | }
242 | 
243 | void test_relational() {
244 |   test_relational_basic<int, long>();
245 |   test_relational_basic<ComparesToMyBool, int>();
246 |   test_relational_basic<int, ComparesToMyBool>();
247 |   test_relational_basic<ComparesToMyBool, ComparesToMyBool>();
248 | #ifndef TEST_HAS_NO_EXCEPTIONS
249 |   { // LHS.index() < RHS.index(), RHS is empty
250 |     using V = swl::variant<int, MakeEmptyT>;
251 |     V v1;
252 |     V v2;
253 |     makeEmpty(v2);
254 |     SWL_ASSERT(test_less(v1, v2, false, true));
255 |   }
256 |   { // LHS.index() > RHS.index(), LHS is empty
257 |     using V = swl::variant<int, MakeEmptyT>;
258 |     V v1;
259 |     makeEmpty(v1);
260 |     V v2;
261 |     SWL_ASSERT(test_less(v1, v2, true, false));
262 |   }
263 |   { // LHS.index() == RHS.index(), LHS and RHS are empty
264 |     using V = swl::variant<int, MakeEmptyT>;
265 |     V v1;
266 |     makeEmpty(v1);
267 |     V v2;
268 |     makeEmpty(v2);
269 |     SWL_ASSERT(test_less(v1, v2, false, false));
270 |   }
271 | #endif
272 | }
273 | 
274 | int main(int, char**) {
275 |   test_equality();
276 |   test_relational();
277 | 
278 |   SWL_END_TEST_SIGNAL 
279 |  return 0; 
280 | 
281 | }
282 | 


--------------------------------------------------------------------------------
/tests/tests/variant.relops/relops_bool_conv.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types>
15 | // constexpr bool
16 | // operator==(variant<Types...> const&, variant<Types...> const&) noexcept;
17 | //
18 | // template <class ...Types>
19 | // constexpr bool
20 | // operator!=(variant<Types...> const&, variant<Types...> const&) noexcept;
21 | //
22 | // template <class ...Types>
23 | // constexpr bool
24 | // operator<(variant<Types...> const&, variant<Types...> const&) noexcept;
25 | //
26 | // template <class ...Types>
27 | // constexpr bool
28 | // operator>(variant<Types...> const&, variant<Types...> const&) noexcept;
29 | //
30 | // template <class ...Types>
31 | // constexpr bool
32 | // operator<=(variant<Types...> const&, variant<Types...> const&) noexcept;
33 | //
34 | // template <class ...Types>
35 | // constexpr bool
36 | // operator>=(variant<Types...> const&, variant<Types...> const&) noexcept;
37 | 
38 |  
39 | #include <type_traits>
40 | #include <utility>
41 | #include <swl_assert.hpp> 
42 | #include <swl/variant.hpp> 
43 | 
44 | #include "test_macros.h"
45 | 
46 | 
47 | struct MyBoolExplicit {
48 |   bool value;
49 |   constexpr explicit MyBoolExplicit(bool v) : value(v) {}
50 |   constexpr explicit operator bool() const noexcept { return value; }
51 | };
52 | 
53 | struct ComparesToMyBoolExplicit {
54 |   int value = 0;
55 | };
56 | inline constexpr MyBoolExplicit operator==(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
57 |   return MyBoolExplicit(LHS.value == RHS.value);
58 | }
59 | inline constexpr MyBoolExplicit operator!=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
60 |   return MyBoolExplicit(LHS.value != RHS.value);
61 | }
62 | inline constexpr MyBoolExplicit operator<(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
63 |   return MyBoolExplicit(LHS.value < RHS.value);
64 | }
65 | inline constexpr MyBoolExplicit operator<=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
66 |   return MyBoolExplicit(LHS.value <= RHS.value);
67 | }
68 | inline constexpr MyBoolExplicit operator>(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
69 |   return MyBoolExplicit(LHS.value > RHS.value);
70 | }
71 | inline constexpr MyBoolExplicit operator>=(const ComparesToMyBoolExplicit& LHS, const ComparesToMyBoolExplicit& RHS) noexcept {
72 |   return MyBoolExplicit(LHS.value >= RHS.value);
73 | }
74 | 
75 | 
76 | int main(int, char**) {
77 |   using V = swl::variant<int, ComparesToMyBoolExplicit>;
78 |   V v1(42);
79 |   V v2(101);
80 |   // expected-error-re@variant:* 6 {{static_assert failed {{.*}}"the relational operator does not return a type which is implicitly convertible to bool"}}
81 |   // expected-error@variant:* 6 {{no viable conversion}}
82 |   (void)(v1 == v2); // expected-note {{here}}
83 |   (void)(v1 != v2); // expected-note {{here}}
84 |   (void)(v1 < v2); // expected-note {{here}}
85 |   (void)(v1 <= v2); // expected-note {{here}}
86 |   (void)(v1 > v2); // expected-note {{here}}
87 |   (void)(v1 >= v2); // expected-note {{here}}
88 | 
89 |   SWL_END_TEST_SIGNAL 
90 |  return 0; 
91 | 
92 | }
93 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.assign/T.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class T>
 23 | // variant& operator=(T&&) noexcept(see below);
 24 | 
 25 |  
 26 | #include <string>
 27 | #include <type_traits>
 28 | #include <swl_assert.hpp> 
 29 | #include <swl/variant.hpp> 
 30 | #include <memory>
 31 | 
 32 | #include "test_macros.h"
 33 | #include "variant_test_helpers.h"
 34 | 
 35 | namespace MetaHelpers {
 36 | 
 37 | struct Dummy {
 38 |   Dummy() = default;
 39 | };
 40 | 
 41 | struct ThrowsCtorT {
 42 |   ThrowsCtorT(int) noexcept(false) {}
 43 |   ThrowsCtorT &operator=(int) noexcept { return *this; }
 44 | };
 45 | 
 46 | struct ThrowsAssignT {
 47 |   ThrowsAssignT(int) noexcept {}
 48 |   ThrowsAssignT &operator=(int) noexcept(false) { return *this; }
 49 | };
 50 | 
 51 | struct NoThrowT {
 52 |   NoThrowT(int) noexcept {}
 53 |   NoThrowT &operator=(int) noexcept { return *this; }
 54 | };
 55 | 
 56 | } // namespace MetaHelpers
 57 | 
 58 | namespace RuntimeHelpers {
 59 | #ifndef TEST_HAS_NO_EXCEPTIONS
 60 | 
 61 | struct ThrowsCtorT {
 62 |   int value;
 63 |   ThrowsCtorT() : value(0) {}
 64 |   ThrowsCtorT(int) noexcept(false) { throw 42; }
 65 |   ThrowsCtorT &operator=(int v) noexcept {
 66 |     value = v;
 67 |     return *this;
 68 |   }
 69 | };
 70 | 
 71 | struct MoveCrashes {
 72 |   int value;
 73 |   MoveCrashes(int v = 0) noexcept : value{v} {}
 74 |   MoveCrashes(MoveCrashes &&) noexcept { SWL_ASSERT(false); }
 75 |   MoveCrashes &operator=(MoveCrashes &&) noexcept { SWL_ASSERT(false); return *this; }
 76 |   MoveCrashes &operator=(int v) noexcept {
 77 |     value = v;
 78 |     return *this;
 79 |   }
 80 | };
 81 | 
 82 | struct ThrowsCtorTandMove {
 83 |   int value;
 84 |   ThrowsCtorTandMove() : value(0) {}
 85 |   ThrowsCtorTandMove(int) noexcept(false) { throw 42; }
 86 |   ThrowsCtorTandMove(ThrowsCtorTandMove &&) noexcept(false) { SWL_ASSERT(false); }
 87 |   ThrowsCtorTandMove &operator=(int v) noexcept {
 88 |     value = v;
 89 |     return *this;
 90 |   }
 91 | };
 92 | 
 93 | struct ThrowsAssignT {
 94 |   int value;
 95 |   ThrowsAssignT() : value(0) {}
 96 |   ThrowsAssignT(int v) noexcept : value(v) {}
 97 |   ThrowsAssignT &operator=(int) noexcept(false) { throw 42; }
 98 | };
 99 | 
100 | struct NoThrowT {
101 |   int value;
102 |   NoThrowT() : value(0) {}
103 |   NoThrowT(int v) noexcept : value(v) {}
104 |   NoThrowT &operator=(int v) noexcept {
105 |     value = v;
106 |     return *this;
107 |   }
108 | };
109 | 
110 | #endif // !defined(TEST_HAS_NO_EXCEPTIONS)
111 | } // namespace RuntimeHelpers
112 | 
113 | void test_T_assignment_noexcept() {
114 |   using namespace MetaHelpers;
115 |   {
116 |     using V = swl::variant<Dummy, NoThrowT>;
117 |     static_assert(std::is_nothrow_assignable<V, int>::value, "");
118 |   }
119 |   {
120 |     using V = swl::variant<Dummy, ThrowsCtorT>;
121 |     static_assert(!std::is_nothrow_assignable<V, int>::value, "");
122 |   }
123 |   {
124 |     using V = swl::variant<Dummy, ThrowsAssignT>;
125 |     static_assert(!std::is_nothrow_assignable<V, int>::value, "");
126 |   }
127 | }
128 | 
129 | void test_T_assignment_sfinae() {
130 |   {
131 |     using V = swl::variant<long, long long>;
132 |     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
133 |   }
134 |   {
135 |     using V = swl::variant<std::string, std::string>;
136 |     static_assert(!std::is_assignable<V, const char *>::value, "ambiguous");
137 |   }
138 |   {
139 |     using V = swl::variant<std::string, void *>;
140 |     static_assert(!std::is_assignable<V, int>::value, "no matching operator=");
141 |   }
142 |   {
143 |     using V = swl::variant<std::string, float>;
144 |     static_assert(std::is_assignable<V, int>::value == VariantAllowsNarrowingConversions,
145 |     "no matching operator=");
146 |   }
147 |   {
148 |     using V = swl::variant<std::unique_ptr<int>, bool>;
149 |     static_assert(!std::is_assignable<V, std::unique_ptr<char>>::value,
150 |                   "no explicit bool in operator=");
151 |     struct X {
152 |       operator void*();
153 |     };
154 |     static_assert(!std::is_assignable<V, X>::value,
155 |                   "no boolean conversion in operator=");
156 | 	// swl note : unlike libc++ implementation, we allow some boolean conversion
157 |     /* static_assert(!std::is_assignable<V, std::false_type>::value,
158 |                   "no converted to bool in operator="); */
159 |   }
160 |   {
161 |     struct X {};
162 |     struct Y {
163 |       operator X();
164 |     };
165 |     using V = swl::variant<X>;
166 |     static_assert(std::is_assignable<V, Y>::value,
167 |                   "regression on user-defined conversions in operator=");
168 |   }
169 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
170 |   {
171 |     using V = swl::variant<int, int &&>;
172 |     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
173 |   }
174 |   {
175 |     using V = swl::variant<int, const int &>;
176 |     static_assert(!std::is_assignable<V, int>::value, "ambiguous");
177 |   }
178 | #endif // TEST_VARIANT_HAS_NO_REFERENCES
179 | }
180 | 
181 | void test_T_assignment_basic() {
182 |   {
183 |     swl::variant<int> v(43);
184 |     v = 42;
185 |     SWL_ASSERT(v.index() == 0);
186 |     SWL_ASSERT(swl::get<0>(v) == 42);
187 |   }
188 |   {
189 |     swl::variant<int, long> v(43l);
190 |     v = 42;
191 |     SWL_ASSERT(v.index() == 0);
192 |     SWL_ASSERT(swl::get<0>(v) == 42);
193 |     v = 43l;
194 |     SWL_ASSERT(v.index() == 1);
195 |     SWL_ASSERT(swl::get<1>(v) == 43);
196 |   }
197 | #ifndef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
198 |   {
199 |     swl::variant<unsigned, long> v;
200 |     v = 42;
201 |     SWL_ASSERT(v.index() == 1);
202 |     SWL_ASSERT(swl::get<1>(v) == 42);
203 |     v = 43u;
204 |     SWL_ASSERT(v.index() == 0);
205 |     SWL_ASSERT(swl::get<0>(v) == 43);
206 |   }
207 | #endif
208 |   {
209 |     swl::variant<std::string, bool> v = true;
210 |     v = "bar";
211 |     SWL_ASSERT(v.index() == 0);
212 |     SWL_ASSERT(swl::get<0>(v) == "bar");
213 |   }
214 |   {
215 |     swl::variant<bool, std::unique_ptr<int>> v;
216 |     v = nullptr;
217 |     SWL_ASSERT(v.index() == 1);
218 |     SWL_ASSERT(swl::get<1>(v) == nullptr);
219 |   }
220 |   {
221 |     swl::variant<bool volatile, int> v = 42;
222 |     v = false;
223 |     SWL_ASSERT(v.index() == 0);
224 |     SWL_ASSERT(!swl::get<0>(v));
225 |     bool lvt = true;
226 |     v = lvt;
227 |     SWL_ASSERT(v.index() == 0);
228 |     SWL_ASSERT(swl::get<0>(v));
229 |   }
230 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
231 |   {
232 |     using V = swl::variant<int &, int &&, long>;
233 |     int x = 42;
234 |     V v(43l);
235 |     v = x;
236 |     SWL_ASSERT(v.index() == 0);
237 |     SWL_ASSERT(&swl::get<0>(v) == &x);
238 |     v = std::move(x);
239 |     SWL_ASSERT(v.index() == 1);
240 |     SWL_ASSERT(&swl::get<1>(v) == &x);
241 |     // 'long' is selected by FUN(const int &) since 'const int &' cannot bind
242 |     // to 'int&'.
243 |     const int &cx = x;
244 |     v = cx;
245 |     SWL_ASSERT(v.index() == 2);
246 |     SWL_ASSERT(swl::get<2>(v) == 42);
247 |   }
248 | #endif // TEST_VARIANT_HAS_NO_REFERENCES
249 | }
250 | 
251 | void test_T_assignment_performs_construction() {
252 |   using namespace RuntimeHelpers;
253 | #ifndef TEST_HAS_NO_EXCEPTIONS
254 |   {
255 |     using V = swl::variant<std::string, ThrowsCtorT>;
256 |     V v(swl::in_place_type<std::string>, "hello");
257 |     try {
258 |       v = 42;
259 |       SWL_ASSERT(false);
260 |     } catch (...) { /* ... */
261 |     }
262 |     SWL_ASSERT(v.index() == 0);
263 |     SWL_ASSERT(swl::get<0>(v) == "hello");
264 |   }
265 |   {
266 |     using V = swl::variant<ThrowsAssignT, std::string>;
267 |     V v(swl::in_place_type<std::string>, "hello");
268 |     v = 42;
269 |     SWL_ASSERT(v.index() == 0);
270 |     SWL_ASSERT(swl::get<0>(v).value == 42);
271 |   }
272 | #endif // TEST_HAS_NO_EXCEPTIONS
273 | }
274 | 
275 | void test_T_assignment_performs_assignment() {
276 |   using namespace RuntimeHelpers;
277 | #ifndef TEST_HAS_NO_EXCEPTIONS
278 |   {
279 |     using V = swl::variant<ThrowsCtorT>;
280 |     V v;
281 |     v = 42;
282 |     SWL_ASSERT(v.index() == 0);
283 |     SWL_ASSERT(swl::get<0>(v).value == 42);
284 |   }
285 |   {
286 |     using V = swl::variant<ThrowsCtorT, std::string>;
287 |     V v;
288 |     v = 42;
289 |     SWL_ASSERT(v.index() == 0);
290 |     SWL_ASSERT(swl::get<0>(v).value == 42);
291 |   }
292 |   {
293 |     using V = swl::variant<ThrowsAssignT>;
294 |     V v(100);
295 |     try {
296 |       v = 42;
297 |       SWL_ASSERT(false);
298 |     } catch (...) { /* ... */
299 |     }
300 |     SWL_ASSERT(v.index() == 0);
301 |     SWL_ASSERT(swl::get<0>(v).value == 100);
302 |   }
303 |   {
304 |     using V = swl::variant<std::string, ThrowsAssignT>;
305 |     V v(100);
306 |     try {
307 |       v = 42;
308 |       SWL_ASSERT(false);
309 |     } catch (...) { /* ... */
310 |     }
311 |     SWL_ASSERT(v.index() == 1);
312 |     SWL_ASSERT(swl::get<1>(v).value == 100);
313 |   }
314 | #endif // TEST_HAS_NO_EXCEPTIONS
315 | }
316 | 
317 | int main(int, char**) {
318 |   test_T_assignment_basic();
319 |   test_T_assignment_performs_construction();
320 |   test_T_assignment_performs_assignment();
321 |   test_T_assignment_noexcept();
322 |   test_T_assignment_sfinae();
323 | 
324 |   SWL_END_TEST_SIGNAL 
325 |  return 0; 
326 | 
327 | }
328 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.assign/conv.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | // template <class T>
17 | // variant& operator=(T&&) noexcept(see below);
18 | 
19 | #include <swl_assert.hpp> 
20 | #include <swl/variant.hpp> 
21 | #include <string>
22 | #include <memory>
23 | 
24 | #include "variant_test_helpers.h"
25 | 
26 | int main(int, char**)
27 | {
28 |   static_assert(!std::is_assignable<swl::variant<int, int>, int>::value, "");
29 |   static_assert(!std::is_assignable<swl::variant<long, long long>, int>::value, "");
30 |   static_assert(std::is_assignable<swl::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
31 | 
32 |   static_assert(std::is_assignable<swl::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, "");
33 |   static_assert(std::is_assignable<swl::variant<std::string, double>, int>::value == VariantAllowsNarrowingConversions, "");
34 |   static_assert(!std::is_assignable<swl::variant<std::string, bool>, int>::value, "");
35 | 
36 |   static_assert(!std::is_assignable<swl::variant<int, bool>, decltype("meow")>::value, "");
37 |   static_assert(!std::is_assignable<swl::variant<int, const bool>, decltype("meow")>::value, "");
38 |   static_assert(!std::is_assignable<swl::variant<int, const volatile bool>, decltype("meow")>::value, "");
39 |   
40 |   // libc++ implementation completely forbids any implicit conversion to bool, not swl::variant
41 |   // static_assert(!std::is_assignable<swl::variant<bool>, std::true_type>::value, ""); 
42 |   static_assert(!std::is_assignable<swl::variant<bool>, std::unique_ptr<char> >::value, "");
43 |   static_assert(!std::is_assignable<swl::variant<bool>, decltype(nullptr)>::value, "");
44 | 
45 |   SWL_END_TEST_SIGNAL 
46 |  return 0; 
47 | 
48 | }
49 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.assign/copy.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // LWG issue 3024
15 | 
16 | #include <swl_assert.hpp> 
17 | #include <swl/variant.hpp> 
18 | #include <type_traits>
19 | 
20 | struct NotCopyConstructible
21 | {
22 |     NotCopyConstructible() = default;
23 |     NotCopyConstructible(NotCopyConstructible const&) = delete;
24 | };
25 | 
26 | int main(int, char**)
27 | {
28 |     static_assert(!std::is_copy_constructible_v<NotCopyConstructible>);
29 | 
30 |     swl::variant<NotCopyConstructible> v;
31 |     swl::variant<NotCopyConstructible> v1;
32 |     swl::variant<NotCopyConstructible> v2(v); // expected-error {{call to implicitly-deleted copy constructor of 'swl::variant<NotCopyConstructible>'}}
33 |     v1 = v; // expected-error-re {{object of type 'std:{{.*}}:variant<NotCopyConstructible>' cannot be assigned because its copy assignment operator is implicitly deleted}}
34 | }
35 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/T.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class T> constexpr variant(T&&) noexcept(see below);
 23 | 
 24 |  
 25 | #include <string>
 26 | #include <type_traits>
 27 | #include <swl_assert.hpp> 
 28 | #include <swl/variant.hpp> 
 29 | #include <memory>
 30 | 
 31 | #include "test_macros.h"
 32 | #include "variant_test_helpers.h"
 33 | 
 34 | struct Dummy {
 35 |   Dummy() = default;
 36 | };
 37 | 
 38 | struct ThrowsT {
 39 |   ThrowsT(int) noexcept(false) {}
 40 | };
 41 | 
 42 | struct NoThrowT {
 43 |   NoThrowT(int) noexcept(true) {}
 44 | };
 45 | 
 46 | struct AnyConstructible { template <typename T> AnyConstructible(T&&) {} };
 47 | struct NoConstructible { NoConstructible() = delete; };
 48 | template <class T>
 49 | struct RValueConvertibleFrom { RValueConvertibleFrom(T&&) {} };
 50 | 
 51 | void test_T_ctor_noexcept() {
 52 |   {
 53 |     using V = swl::variant<Dummy, NoThrowT>;
 54 |     static_assert(std::is_nothrow_constructible<V, int>::value, "");
 55 |   }
 56 |   {
 57 |     using V = swl::variant<Dummy, ThrowsT>;
 58 |     static_assert(!std::is_nothrow_constructible<V, int>::value, "");
 59 |   }
 60 | }
 61 | 
 62 | void test_T_ctor_sfinae() {
 63 |   {
 64 |     using V = swl::variant<long, long long>;
 65 |     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
 66 |   }
 67 |   {
 68 |     using V = swl::variant<std::string, std::string>;
 69 |     static_assert(!std::is_constructible<V, const char *>::value, "ambiguous");
 70 |   }
 71 |   {
 72 |     using V = swl::variant<std::string, void *>;
 73 |     static_assert(!std::is_constructible<V, int>::value,
 74 |                   "no matching constructor");
 75 |   }
 76 |   {
 77 |     using V = swl::variant<std::string, float>;
 78 |     static_assert(std::is_constructible<V, int>::value == VariantAllowsNarrowingConversions,
 79 |                   "no matching constructor");
 80 |   }
 81 |   {
 82 |     using V = swl::variant<std::unique_ptr<int>, bool>;
 83 |     static_assert(!std::is_constructible<V, std::unique_ptr<char>>::value,
 84 |                   "no explicit bool in constructor");
 85 |     struct X {
 86 |       operator void*();
 87 |     };
 88 |     static_assert(!std::is_constructible<V, X>::value,
 89 |                   "no boolean conversion in constructor");
 90 |     /* static_assert(!std::is_constructible<V, std::false_type>::value,
 91 |                   "no converted to bool in constructor"); */
 92 |   }
 93 |   {
 94 |     struct X {};
 95 |     struct Y {
 96 |       operator X();
 97 |     };
 98 |     using V = swl::variant<X>;
 99 |     static_assert(std::is_constructible<V, Y>::value,
100 |                   "regression on user-defined conversions in constructor");
101 |   }
102 |   {
103 |     using V = swl::variant<AnyConstructible, NoConstructible>;
104 |     static_assert(
105 |         !std::is_constructible<V, swl::in_place_type_t<NoConstructible>>::value,
106 |         "no matching constructor");
107 |     static_assert(!std::is_constructible<V, swl::in_place_index_t<1>>::value,
108 |                   "no matching constructor");
109 |   }
110 | 
111 | 
112 | 
113 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
114 |   {
115 |     using V = swl::variant<int, int &&>;
116 |     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
117 |   }
118 |   {
119 |     using V = swl::variant<int, const int &>;
120 |     static_assert(!std::is_constructible<V, int>::value, "ambiguous");
121 |   }
122 | #endif
123 | }
124 | 
125 | void test_T_ctor_basic() {
126 |   {
127 |     constexpr swl::variant<int> v(42);
128 |     static_assert(v.index() == 0, "");
129 |     static_assert(swl::get<0>(v) == 42, "");
130 |   }
131 |   {
132 |     constexpr swl::variant<int, long> v(42l);
133 |     static_assert(v.index() == 1, "");
134 |     static_assert(swl::get<1>(v) == 42, "");
135 |   }
136 | #ifndef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
137 |   {
138 |     constexpr swl::variant<unsigned, long> v(42);
139 |     static_assert(v.index() == 1, "");
140 |     static_assert(swl::get<1>(v) == 42, "");
141 |   }
142 | #endif
143 |   {
144 |     swl::variant<std::string, bool const> v = "foo";
145 |     SWL_ASSERT(v.index() == 0);
146 |     SWL_ASSERT(swl::get<0>(v) == "foo");
147 |   }
148 |   {
149 |     swl::variant<bool volatile, std::unique_ptr<int>> v = nullptr;
150 |     SWL_ASSERT(v.index() == 1);
151 |     SWL_ASSERT(swl::get<1>(v) == nullptr);
152 |   }
153 |   {
154 |     swl::variant<bool volatile const, int> v = true;
155 |     SWL_ASSERT(v.index() == 0);
156 |     SWL_ASSERT(swl::get<0>(v));
157 |   }
158 |   {
159 |     swl::variant<RValueConvertibleFrom<int>> v1 = 42;
160 |     SWL_ASSERT(v1.index() == 0);
161 | 
162 |     int x = 42;
163 |     swl::variant<RValueConvertibleFrom<int>, AnyConstructible> v2 = x;
164 |     SWL_ASSERT(v2.index() == 1);
165 |   }
166 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
167 |   {
168 |     using V = swl::variant<const int &, int &&, long>;
169 |     static_assert(std::is_convertible<int &, V>::value, "must be implicit");
170 |     int x = 42;
171 |     V v(x);
172 |     SWL_ASSERT(v.index() == 0);
173 |     SWL_ASSERT(&swl::get<0>(v) == &x);
174 |   }
175 |   {
176 |     using V = swl::variant<const int &, int &&, long>;
177 |     static_assert(std::is_convertible<int, V>::value, "must be implicit");
178 |     int x = 42;
179 |     V v(std::move(x));
180 |     SWL_ASSERT(v.index() == 1);
181 |     SWL_ASSERT(&swl::get<1>(v) == &x);
182 |   }
183 | #endif
184 | }
185 | 
186 | struct BoomOnAnything {
187 |   template <class T>
188 |   constexpr BoomOnAnything(T) { static_assert(!std::is_same<T, T>::value, ""); }
189 | };
190 | 
191 | void test_no_narrowing_check_for_class_types() {
192 |   using V = swl::variant<int, BoomOnAnything>;
193 |   V v(42);
194 |   SWL_ASSERT(v.index() == 0);
195 |   SWL_ASSERT(swl::get<0>(v) == 42);
196 | }
197 | 
198 | struct Bar {};
199 | struct Baz {};
200 | void test_construction_with_repeated_types() {
201 |   using V = swl::variant<int, Bar, Baz, int, Baz, int, int>;
202 |   static_assert(!std::is_constructible<V, int>::value, "");
203 |   static_assert(!std::is_constructible<V, Baz>::value, "");
204 |   // OK, the selected type appears only once and so it shouldn't
205 |   // be affected by the duplicate types.
206 |   static_assert(std::is_constructible<V, Bar>::value, "");
207 | }
208 | 
209 | int main(int, char**) {
210 |   test_T_ctor_basic();
211 |   test_T_ctor_noexcept();
212 |   test_T_ctor_sfinae();
213 |   test_no_narrowing_check_for_class_types();
214 |   test_construction_with_repeated_types();
215 |   SWL_END_TEST_SIGNAL 
216 |  return 0; 
217 | 
218 | }
219 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/conv.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | // template <class T> constexpr variant(T&&) noexcept(see below);
17 | 
18 | #include <swl_assert.hpp> 
19 | #include <swl/variant.hpp> 
20 | #include <string>
21 | #include <memory>
22 | 
23 | #include "variant_test_helpers.h"
24 | 
25 | int main(int, char**)
26 | {
27 |   static_assert(!std::is_constructible<swl::variant<int, int>, int>::value, "");
28 |   static_assert(!std::is_constructible<swl::variant<long, long long>, int>::value, "");
29 |   static_assert(std::is_constructible<swl::variant<char>, int>::value == VariantAllowsNarrowingConversions, "");
30 | 
31 |   static_assert(std::is_constructible<swl::variant<std::string, float>, int>::value == VariantAllowsNarrowingConversions, "");
32 |   static_assert(std::is_constructible<swl::variant<std::string, double>, int>::value == VariantAllowsNarrowingConversions, "");
33 |   static_assert(!std::is_constructible<swl::variant<std::string, bool>, int>::value, "");
34 | 
35 |   static_assert(!std::is_constructible<swl::variant<int, bool>, decltype("meow")>::value, "");
36 |   static_assert(!std::is_constructible<swl::variant<int, const bool>, decltype("meow")>::value, "");
37 |   static_assert(!std::is_constructible<swl::variant<int, const volatile bool>, decltype("meow")>::value, "");
38 | 
39 |   //static_assert(!std::is_constructible<swl::variant<bool>, std::true_type>::value, "");
40 |   static_assert(!std::is_constructible<swl::variant<bool>, std::unique_ptr<char> >::value, "");
41 |   static_assert(!std::is_constructible<swl::variant<bool>, decltype(nullptr)>::value, "");
42 | 
43 |   SWL_END_TEST_SIGNAL 
44 |  return 0; 
45 | 
46 | }
47 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/copy.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // variant(variant const&); // constexpr in C++20
 23 | 
 24 |  
 25 | #include <type_traits>
 26 | #include <swl_assert.hpp> 
 27 | #include <swl/variant.hpp> 
 28 | 
 29 | #include "test_macros.h"
 30 | #include "test_workarounds.h"
 31 | 
 32 | struct NonT {
 33 |   NonT(int v) : value(v) {}
 34 |   NonT(const NonT &o) : value(o.value) {}
 35 |   int value;
 36 | };
 37 | static_assert(!std::is_trivially_copy_constructible<NonT>::value, "");
 38 | 
 39 | struct NoCopy {
 40 |   NoCopy(const NoCopy &) = delete;
 41 | };
 42 | 
 43 | struct MoveOnly {
 44 |   MoveOnly(const MoveOnly &) = delete;
 45 |   MoveOnly(MoveOnly &&) = default;
 46 | };
 47 | 
 48 | struct MoveOnlyNT {
 49 |   MoveOnlyNT(const MoveOnlyNT &) = delete;
 50 |   MoveOnlyNT(MoveOnlyNT &&) {}
 51 | };
 52 | 
 53 | struct NTCopy {
 54 |   constexpr NTCopy(int v) : value(v) {}
 55 |   NTCopy(const NTCopy &that) : value(that.value) {}
 56 |   NTCopy(NTCopy &&) = delete;
 57 |   int value;
 58 | };
 59 | 
 60 | static_assert(!std::is_trivially_copy_constructible<NTCopy>::value, "");
 61 | static_assert(std::is_copy_constructible<NTCopy>::value, "");
 62 | 
 63 | struct TCopy {
 64 |   constexpr TCopy(int v) : value(v) {}
 65 |   TCopy(TCopy const &) = default;
 66 |   TCopy(TCopy &&) = delete;
 67 |   int value;
 68 | };
 69 | 
 70 | static_assert(std::is_trivially_copy_constructible<TCopy>::value, "");
 71 | 
 72 | struct TCopyNTMove {
 73 |   constexpr TCopyNTMove(int v) : value(v) {}
 74 |   TCopyNTMove(const TCopyNTMove&) = default;
 75 |   TCopyNTMove(TCopyNTMove&& that) : value(that.value) { that.value = -1; }
 76 |   int value;
 77 | };
 78 | 
 79 | static_assert(std::is_trivially_copy_constructible<TCopyNTMove>::value, "");
 80 | 
 81 | #ifndef TEST_HAS_NO_EXCEPTIONS
 82 | struct MakeEmptyT {
 83 |   static int alive;
 84 |   MakeEmptyT() { ++alive; }
 85 |   MakeEmptyT(const MakeEmptyT &) {
 86 |     ++alive;
 87 |     // Don't throw from the copy constructor since variant's assignment
 88 |     // operator performs a copy before committing to the assignment.
 89 |   }
 90 |   MakeEmptyT(MakeEmptyT &&) { throw 42; }
 91 |   MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
 92 |   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
 93 |   ~MakeEmptyT() { --alive; }
 94 | };
 95 | 
 96 | int MakeEmptyT::alive = 0;
 97 | 
 98 | template <class Variant> void makeEmpty(Variant &v) {
 99 |   Variant v2(swl::in_place_type<MakeEmptyT>);
100 |   try {
101 |     v = std::move(v2);
102 |     SWL_ASSERT(false);
103 |   } catch (...) {
104 |     SWL_ASSERT(v.valueless_by_exception());
105 |   }
106 | }
107 | #endif // TEST_HAS_NO_EXCEPTIONS
108 | 
109 | void test_copy_ctor_sfinae() {
110 |   {
111 |     using V = swl::variant<int, long>;
112 |     static_assert(std::is_copy_constructible<V>::value, "");
113 |   }
114 |   {
115 |     using V = swl::variant<int, NoCopy>;
116 |     static_assert(!std::is_copy_constructible<V>::value, "");
117 |   }
118 |   {
119 |     using V = swl::variant<int, MoveOnly>;
120 |     static_assert(!std::is_copy_constructible<V>::value, "");
121 |   }
122 |   {
123 |     using V = swl::variant<int, MoveOnlyNT>;
124 |     static_assert(!std::is_copy_constructible<V>::value, "");
125 |   }
126 | 
127 |   // Make sure we properly propagate triviality (see P0602R4).
128 | #if TEST_STD_VER > 17
129 |   {
130 |     using V = swl::variant<int, long>;
131 |     static_assert(std::is_trivially_copy_constructible<V>::value, "");
132 |   }
133 |   {
134 |     using V = swl::variant<int, NTCopy>;
135 |     static_assert(!std::is_trivially_copy_constructible<V>::value, "");
136 |     static_assert(std::is_copy_constructible<V>::value, "");
137 |   }
138 |   {
139 |     using V = swl::variant<int, TCopy>;
140 |     static_assert(std::is_trivially_copy_constructible<V>::value, "");
141 |   }
142 |   {
143 |     using V = swl::variant<int, TCopyNTMove>;
144 |     static_assert(std::is_trivially_copy_constructible<V>::value, "");
145 |   }
146 | #endif // > C++17
147 | }
148 | 
149 | void test_copy_ctor_basic() {
150 |   {
151 |     swl::variant<int> v(swl::in_place_index<0>, 42);
152 |     swl::variant<int> v2 = v;
153 |     SWL_ASSERT(v2.index() == 0);
154 |     SWL_ASSERT(swl::get<0>(v2) == 42);
155 |   }
156 |   {
157 |     swl::variant<int, long> v(swl::in_place_index<1>, 42);
158 |     swl::variant<int, long> v2 = v;
159 |     SWL_ASSERT(v2.index() == 1);
160 |     SWL_ASSERT(swl::get<1>(v2) == 42);
161 |   }
162 |   {
163 |     swl::variant<NonT> v(swl::in_place_index<0>, 42);
164 |     SWL_ASSERT(v.index() == 0);
165 |     swl::variant<NonT> v2(v);
166 |     SWL_ASSERT(v2.index() == 0);
167 |     SWL_ASSERT(swl::get<0>(v2).value == 42);
168 |   }
169 |   {
170 |     swl::variant<int, NonT> v(swl::in_place_index<1>, 42);
171 |     SWL_ASSERT(v.index() == 1);
172 |     swl::variant<int, NonT> v2(v);
173 |     SWL_ASSERT(v2.index() == 1);
174 |     SWL_ASSERT(swl::get<1>(v2).value == 42);
175 |   }
176 | 
177 |   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
178 | #if TEST_STD_VER > 17
179 |   {
180 |     constexpr swl::variant<int> v(swl::in_place_index<0>, 42);
181 |     static_assert(v.index() == 0, "");
182 |     constexpr swl::variant<int> v2 = v;
183 |     static_assert(v2.index() == 0, "");
184 |     static_assert(swl::get<0>(v2) == 42, "");
185 |   }
186 |   {
187 |     constexpr swl::variant<int, long> v(swl::in_place_index<1>, 42);
188 |     static_assert(v.index() == 1, "");
189 |     constexpr swl::variant<int, long> v2 = v;
190 |     static_assert(v2.index() == 1, "");
191 |     static_assert(swl::get<1>(v2) == 42, "");
192 |   }
193 |   {
194 |     constexpr swl::variant<TCopy> v(swl::in_place_index<0>, 42);
195 |     static_assert(v.index() == 0, "");
196 |     constexpr swl::variant<TCopy> v2(v);
197 |     static_assert(v2.index() == 0, "");
198 |     static_assert(swl::get<0>(v2).value == 42, "");
199 |   }
200 |   {
201 |     constexpr swl::variant<int, TCopy> v(swl::in_place_index<1>, 42);
202 |     static_assert(v.index() == 1, "");
203 |     constexpr swl::variant<int, TCopy> v2(v);
204 |     static_assert(v2.index() == 1, "");
205 |     static_assert(swl::get<1>(v2).value == 42, "");
206 |   }
207 |   {
208 |     constexpr swl::variant<TCopyNTMove> v(swl::in_place_index<0>, 42);
209 |     static_assert(v.index() == 0, "");
210 |     constexpr swl::variant<TCopyNTMove> v2(v);
211 |     static_assert(v2.index() == 0, "");
212 |     static_assert(swl::get<0>(v2).value == 42, "");
213 |   }
214 |   {
215 |     constexpr swl::variant<int, TCopyNTMove> v(swl::in_place_index<1>, 42);
216 |     static_assert(v.index() == 1, "");
217 |     constexpr swl::variant<int, TCopyNTMove> v2(v);
218 |     static_assert(v2.index() == 1, "");
219 |     static_assert(swl::get<1>(v2).value == 42, "");
220 |   }
221 | #endif // > C++17
222 | }
223 | 
224 | void test_copy_ctor_valueless_by_exception() {
225 | #ifndef TEST_HAS_NO_EXCEPTIONS
226 |   using V = swl::variant<int, MakeEmptyT>;
227 |   V v1;
228 |   makeEmpty(v1);
229 |   const V &cv1 = v1;
230 |   V v(cv1);
231 |   SWL_ASSERT(v.valueless_by_exception());
232 | #endif // TEST_HAS_NO_EXCEPTIONS
233 | }
234 | 
235 | template <size_t Idx>
236 | constexpr bool test_constexpr_copy_ctor_imp(swl::variant<long, void*, const int> const& v) {
237 |   auto v2 = v;
238 |   return v2.index() == v.index() &&
239 |          v2.index() == Idx &&
240 |          swl::get<Idx>(v2) == swl::get<Idx>(v);
241 | }
242 | 
243 | void test_constexpr_copy_ctor() {
244 |   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
245 | #if TEST_STD_VER > 17
246 |   using V = swl::variant<long, void*, const int>;
247 | #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
248 |   static_assert(std::is_trivially_destructible<V>::value, "");
249 |   static_assert(std::is_trivially_copy_constructible<V>::value, "");
250 |   static_assert(std::is_trivially_move_constructible<V>::value, "");
251 |   static_assert(!std::is_copy_assignable<V>::value, "");
252 |   static_assert(!std::is_move_assignable<V>::value, "");
253 | #else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
254 | 	
255 | 	// SWL-FIXME : GCC is broken here? 
256 | 	// GCC lib implementation doesn't pass this requirement,
257 | 	// but clang one does
258 | 	//static_assert(std::is_trivially_copyable<V>::value, "");
259 | 	
260 | #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
261 |   static_assert(test_constexpr_copy_ctor_imp<0>(V(42l)), "");
262 |   static_assert(test_constexpr_copy_ctor_imp<1>(V(nullptr)), "");
263 |   static_assert(test_constexpr_copy_ctor_imp<2>(V(101)), "");
264 | #endif // > C++17
265 | }
266 | 
267 | int main(int, char**) {
268 |   test_copy_ctor_basic();
269 |   test_copy_ctor_valueless_by_exception();
270 |   test_copy_ctor_sfinae();
271 |   test_constexpr_copy_ctor();
272 | #if 0
273 | // disable this for the moment; it fails on older compilers.
274 | //  Need to figure out which compilers will support it.
275 | { // This is the motivating example from P0739R0
276 |   swl::variant<int, double> v1(3);
277 |   swl::variant v2 = v1;
278 |   (void) v2;
279 | }
280 | #endif
281 | 
282 |   SWL_END_TEST_SIGNAL 
283 |  return 0; 
284 | 
285 | }
286 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/default.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // constexpr variant() noexcept(see below);
 23 | 
 24 |  
 25 | #include <type_traits>
 26 | #include <swl_assert.hpp> 
 27 | #include <swl/variant.hpp> 
 28 | 
 29 | #include "test_macros.h"
 30 | #include "variant_test_helpers.h"
 31 | 
 32 | struct NonDefaultConstructible {
 33 |   constexpr NonDefaultConstructible(int) {}
 34 | };
 35 | 
 36 | struct NotNoexcept {
 37 |   NotNoexcept() noexcept(false) {}
 38 | };
 39 | 
 40 | #ifndef TEST_HAS_NO_EXCEPTIONS
 41 | struct DefaultCtorThrows {
 42 |   DefaultCtorThrows() { throw 42; }
 43 | };
 44 | #endif
 45 | 
 46 | void test_default_ctor_sfinae() {
 47 |   {
 48 |     using V = swl::variant<swl::monostate, int>;
 49 |     static_assert(std::is_default_constructible<V>::value, "");
 50 |   }
 51 |   {
 52 |     using V = swl::variant<NonDefaultConstructible, int>;
 53 |     static_assert(!std::is_default_constructible<V>::value, "");
 54 |   }
 55 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 56 |   {
 57 |     using V = swl::variant<int &, int>;
 58 |     static_assert(!std::is_default_constructible<V>::value, "");
 59 |   }
 60 | #endif
 61 | }
 62 | 
 63 | void test_default_ctor_noexcept() {
 64 |   {
 65 |     using V = swl::variant<int>;
 66 |     static_assert(std::is_nothrow_default_constructible<V>::value, "");
 67 |   }
 68 |   {
 69 |     using V = swl::variant<NotNoexcept>;
 70 |     static_assert(!std::is_nothrow_default_constructible<V>::value, "");
 71 |   }
 72 | }
 73 | 
 74 | void test_default_ctor_throws() {
 75 | #ifndef TEST_HAS_NO_EXCEPTIONS
 76 |   using V = swl::variant<DefaultCtorThrows, int>;
 77 |   try {
 78 |     V v;
 79 |     SWL_ASSERT(false);
 80 |   } catch (const int &ex) {
 81 |     SWL_ASSERT(ex == 42);
 82 |   } catch (...) {
 83 |     SWL_ASSERT(false);
 84 |   }
 85 | #endif
 86 | }
 87 | 
 88 | void test_default_ctor_basic() {
 89 |   {
 90 |     swl::variant<int> v;
 91 |     SWL_ASSERT(v.index() == 0);
 92 |     SWL_ASSERT(swl::get<0>(v) == 0);
 93 |   }
 94 |   {
 95 |     swl::variant<int, long> v;
 96 |     SWL_ASSERT(v.index() == 0);
 97 |     SWL_ASSERT(swl::get<0>(v) == 0);
 98 |   }
 99 |   {
100 |     swl::variant<int, NonDefaultConstructible> v;
101 |     SWL_ASSERT(v.index() == 0);
102 |     SWL_ASSERT(swl::get<0>(v) == 0);
103 |   }
104 |   {
105 |     using V = swl::variant<int, long>;
106 |     constexpr V v;
107 |     static_assert(v.index() == 0, "");
108 |     static_assert(swl::get<0>(v) == 0, "");
109 |   }
110 |   {
111 |     using V = swl::variant<int, long>;
112 |     constexpr V v;
113 |     static_assert(v.index() == 0, "");
114 |     static_assert(swl::get<0>(v) == 0, "");
115 |   }
116 |   {
117 |     using V = swl::variant<int, NonDefaultConstructible>;
118 |     constexpr V v;
119 |     static_assert(v.index() == 0, "");
120 |     static_assert(swl::get<0>(v) == 0, "");
121 |   }
122 | }
123 | 
124 | int main(int, char**) {
125 |   test_default_ctor_basic();
126 |   test_default_ctor_sfinae();
127 |   test_default_ctor_noexcept();
128 |   test_default_ctor_throws();
129 | 
130 |   SWL_END_TEST_SIGNAL 
131 |  return 0; 
132 | 
133 | }
134 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/in_place_index_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <size_t I, class ...Args>
 23 | // constexpr explicit variant(in_place_index_t<I>, Args&&...);
 24 | 
 25 |  
 26 | #include <string>
 27 | #include <type_traits>
 28 | #include <swl_assert.hpp> 
 29 | #include <swl/variant.hpp> 
 30 | 
 31 | #include "test_convertible.h"
 32 | #include "test_macros.h"
 33 | 
 34 | void test_ctor_sfinae() {
 35 |   {
 36 |     using V = swl::variant<int>;
 37 |     static_assert(
 38 |         std::is_constructible<V, swl::in_place_index_t<0>, int>::value, "");
 39 |     static_assert(!test_convertible<V, swl::in_place_index_t<0>, int>(), "");
 40 |   }
 41 |   {
 42 |     using V = swl::variant<int, long, long long>;
 43 |     static_assert(
 44 |         std::is_constructible<V, swl::in_place_index_t<1>, int>::value, "");
 45 |     static_assert(!test_convertible<V, swl::in_place_index_t<1>, int>(), "");
 46 |   }
 47 |   {
 48 |     using V = swl::variant<int, long, int *>;
 49 |     static_assert(
 50 |         std::is_constructible<V, swl::in_place_index_t<2>, int *>::value, "");
 51 |     static_assert(!test_convertible<V, swl::in_place_index_t<2>, int *>(), "");
 52 |   }
 53 |   { // args not convertible to type
 54 |     using V = swl::variant<int, long, int *>;
 55 |     static_assert(
 56 |         !std::is_constructible<V, swl::in_place_index_t<0>, int *>::value, "");
 57 |     static_assert(!test_convertible<V, swl::in_place_index_t<0>, int *>(), "");
 58 |   }
 59 |   { // index not in variant
 60 |     using V = swl::variant<int, long, int *>;
 61 |     static_assert(
 62 |         !std::is_constructible<V, swl::in_place_index_t<3>, int>::value, "");
 63 |     static_assert(!test_convertible<V, swl::in_place_index_t<3>, int>(), "");
 64 |   }
 65 | }
 66 | 
 67 | void test_ctor_basic() {
 68 |   {
 69 |     constexpr swl::variant<int> v(swl::in_place_index<0>, 42);
 70 |     static_assert(v.index() == 0, "");
 71 |     static_assert(swl::get<0>(v) == 42, "");
 72 |   }
 73 |   {
 74 |     constexpr swl::variant<int, long, long> v(swl::in_place_index<1>, 42);
 75 |     static_assert(v.index() == 1, "");
 76 |     static_assert(swl::get<1>(v) == 42, "");
 77 |   }
 78 |   {
 79 |     constexpr swl::variant<int, const int, long> v(swl::in_place_index<1>, 42);
 80 |     static_assert(v.index() == 1, "");
 81 |     static_assert(swl::get<1>(v) == 42, "");
 82 |   }
 83 |   {
 84 |     using V = swl::variant<const int, volatile int, int>;
 85 |     int x = 42;
 86 |     V v(swl::in_place_index<0>, x);
 87 |     SWL_ASSERT(v.index() == 0);
 88 |     SWL_ASSERT(swl::get<0>(v) == x);
 89 |   }
 90 |   {
 91 |     using V = swl::variant<const int, volatile int, int>;
 92 |     int x = 42;
 93 |     V v(swl::in_place_index<1>, x);
 94 |     SWL_ASSERT(v.index() == 1);
 95 |     SWL_ASSERT(swl::get<1>(v) == x);
 96 |   }
 97 |   {
 98 |     using V = swl::variant<const int, volatile int, int>;
 99 |     int x = 42;
100 |     V v(swl::in_place_index<2>, x);
101 |     SWL_ASSERT(v.index() == 2);
102 |     SWL_ASSERT(swl::get<2>(v) == x);
103 |   }
104 | }
105 | 
106 | int main(int, char**) {
107 |   test_ctor_basic();
108 |   test_ctor_sfinae();
109 | 
110 |   SWL_END_TEST_SIGNAL 
111 |  return 0; 
112 | 
113 | }
114 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/in_place_index_init_list_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <size_t I, class Up, class ...Args>
 23 | // constexpr explicit
 24 | // variant(in_place_index_t<I>, initializer_list<Up>, Args&&...);
 25 | 
 26 |  
 27 | #include <string>
 28 | #include <type_traits>
 29 | #include <swl_assert.hpp> 
 30 | #include <swl/variant.hpp> 
 31 | 
 32 | #include "test_convertible.h"
 33 | #include "test_macros.h"
 34 | 
 35 | struct InitList {
 36 |   std::size_t size;
 37 |   constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
 38 | };
 39 | 
 40 | struct InitListArg {
 41 |   std::size_t size;
 42 |   int value;
 43 |   constexpr InitListArg(std::initializer_list<int> il, int v)
 44 |       : size(il.size()), value(v) {}
 45 | };
 46 | 
 47 | void test_ctor_sfinae() {
 48 |   using IL = std::initializer_list<int>;
 49 |   { // just init list
 50 |     using V = swl::variant<InitList, InitListArg, int>;
 51 |     static_assert(std::is_constructible<V, swl::in_place_index_t<0>, IL>::value,
 52 |                   "");
 53 |     static_assert(!test_convertible<V, swl::in_place_index_t<0>, IL>(), "");
 54 |   }
 55 |   { // too many arguments
 56 |     using V = swl::variant<InitList, InitListArg, int>;
 57 |     static_assert(
 58 |         !std::is_constructible<V, swl::in_place_index_t<0>, IL, int>::value,
 59 |         "");
 60 |     static_assert(!test_convertible<V, swl::in_place_index_t<0>, IL, int>(),
 61 |                   "");
 62 |   }
 63 |   { // too few arguments
 64 |     using V = swl::variant<InitList, InitListArg, int>;
 65 |     static_assert(
 66 |         !std::is_constructible<V, swl::in_place_index_t<1>, IL>::value, "");
 67 |     static_assert(!test_convertible<V, swl::in_place_index_t<1>, IL>(), "");
 68 |   }
 69 |   { // init list and arguments
 70 |     using V = swl::variant<InitList, InitListArg, int>;
 71 |     static_assert(
 72 |         std::is_constructible<V, swl::in_place_index_t<1>, IL, int>::value, "");
 73 |     static_assert(!test_convertible<V, swl::in_place_index_t<1>, IL, int>(),
 74 |                   "");
 75 |   }
 76 |   { // not constructible from arguments
 77 |     using V = swl::variant<InitList, InitListArg, int>;
 78 |     static_assert(
 79 |         !std::is_constructible<V, swl::in_place_index_t<2>, IL>::value, "");
 80 |     static_assert(!test_convertible<V, swl::in_place_index_t<2>, IL>(), "");
 81 |   }
 82 |   { // index not in variant
 83 |     using V = swl::variant<InitList, InitListArg, int>;
 84 |     static_assert(
 85 |         !std::is_constructible<V, swl::in_place_index_t<3>, IL>::value, "");
 86 |     static_assert(!test_convertible<V, swl::in_place_index_t<3>, IL>(), "");
 87 |   }
 88 | }
 89 | 
 90 | void test_ctor_basic() {
 91 |   {
 92 |     constexpr swl::variant<InitList, InitListArg, InitList> v(
 93 |         swl::in_place_index<0>, {1, 2, 3});
 94 |     static_assert(v.index() == 0, "");
 95 |     static_assert(swl::get<0>(v).size == 3, "");
 96 |   }
 97 |   {
 98 |     constexpr swl::variant<InitList, InitListArg, InitList> v(
 99 |         swl::in_place_index<2>, {1, 2, 3});
100 |     static_assert(v.index() == 2, "");
101 |     static_assert(swl::get<2>(v).size == 3, "");
102 |   }
103 |   {
104 |     constexpr swl::variant<InitList, InitListArg, InitListArg> v(
105 |         swl::in_place_index<1>, {1, 2, 3, 4}, 42);
106 |     static_assert(v.index() == 1, "");
107 |     static_assert(swl::get<1>(v).size == 4, "");
108 |     static_assert(swl::get<1>(v).value == 42, "");
109 |   }
110 | }
111 | 
112 | int main(int, char**) {
113 |   test_ctor_basic();
114 |   test_ctor_sfinae();
115 | 
116 |   SWL_END_TEST_SIGNAL 
117 |  return 0; 
118 | 
119 | }
120 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/in_place_type_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class Tp, class ...Args>
 23 | // constexpr explicit variant(in_place_type_t<Tp>, Args&&...);
 24 | 
 25 |  
 26 | #include <type_traits>
 27 | #include <swl_assert.hpp> 
 28 | #include <swl/variant.hpp> 
 29 | 
 30 | #include "test_convertible.h"
 31 | #include "test_macros.h"
 32 | 
 33 | void test_ctor_sfinae() {
 34 |   {
 35 |     using V = swl::variant<int>;
 36 |     static_assert(
 37 |         std::is_constructible<V, swl::in_place_type_t<int>, int>::value, "");
 38 |     static_assert(!test_convertible<V, swl::in_place_type_t<int>, int>(), "");
 39 |   }
 40 |   {
 41 |     using V = swl::variant<int, long, long long>;
 42 |     static_assert(
 43 |         std::is_constructible<V, swl::in_place_type_t<long>, int>::value, "");
 44 |     static_assert(!test_convertible<V, swl::in_place_type_t<long>, int>(), "");
 45 |   }
 46 |   {
 47 |     using V = swl::variant<int, long, int *>;
 48 |     static_assert(
 49 |         std::is_constructible<V, swl::in_place_type_t<int *>, int *>::value,
 50 |         "");
 51 |     static_assert(!test_convertible<V, swl::in_place_type_t<int *>, int *>(),
 52 |                   "");
 53 |   }
 54 |   { // duplicate type
 55 |     using V = swl::variant<int, long, int>;
 56 |     static_assert(
 57 |         !std::is_constructible<V, swl::in_place_type_t<int>, int>::value, "");
 58 |     static_assert(!test_convertible<V, swl::in_place_type_t<int>, int>(), "");
 59 |   }
 60 |   { // args not convertible to type
 61 |     using V = swl::variant<int, long, int *>;
 62 |     static_assert(
 63 |         !std::is_constructible<V, swl::in_place_type_t<int>, int *>::value, "");
 64 |     static_assert(!test_convertible<V, swl::in_place_type_t<int>, int *>(), "");
 65 |   }
 66 |   { // type not in variant
 67 |     using V = swl::variant<int, long, int *>;
 68 |     static_assert(
 69 |         !std::is_constructible<V, swl::in_place_type_t<long long>, int>::value,
 70 |         "");
 71 |     static_assert(!test_convertible<V, swl::in_place_type_t<long long>, int>(),
 72 |                   "");
 73 |   }
 74 | }
 75 | 
 76 | void test_ctor_basic() {
 77 |   {
 78 |     constexpr swl::variant<int> v(swl::in_place_type<int>, 42);
 79 |     static_assert(v.index() == 0, "");
 80 |     static_assert(swl::get<0>(v) == 42, "");
 81 |   }
 82 |   {
 83 |     constexpr swl::variant<int, long> v(swl::in_place_type<long>, 42);
 84 |     static_assert(v.index() == 1, "");
 85 |     static_assert(swl::get<1>(v) == 42, "");
 86 |   }
 87 |   {
 88 |     constexpr swl::variant<int, const int, long> v(
 89 |         swl::in_place_type<const int>, 42);
 90 |     static_assert(v.index() == 1, "");
 91 |     static_assert(swl::get<1>(v) == 42, "");
 92 |   }
 93 |   {
 94 |     using V = swl::variant<const int, volatile int, int>;
 95 |     int x = 42;
 96 |     V v(swl::in_place_type<const int>, x);
 97 |     SWL_ASSERT(v.index() == 0);
 98 |     SWL_ASSERT(swl::get<0>(v) == x);
 99 |   }
100 |   {
101 |     using V = swl::variant<const int, volatile int, int>;
102 |     int x = 42;
103 |     V v(swl::in_place_type<volatile int>, x);
104 |     SWL_ASSERT(v.index() == 1);
105 |     SWL_ASSERT(swl::get<1>(v) == x);
106 |   }
107 |   {
108 |     using V = swl::variant<const int, volatile int, int>;
109 |     int x = 42;
110 |     V v(swl::in_place_type<int>, x);
111 |     SWL_ASSERT(v.index() == 2);
112 |     SWL_ASSERT(swl::get<2>(v) == x);
113 |   }
114 | }
115 | 
116 | int main(int, char**) {
117 |   test_ctor_basic();
118 |   test_ctor_sfinae();
119 | 
120 |   SWL_END_TEST_SIGNAL 
121 |  return 0; 
122 | 
123 | }
124 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/in_place_type_init_list_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class Tp, class Up, class ...Args>
 23 | // constexpr explicit
 24 | // variant(in_place_type_t<Tp>, initializer_list<Up>, Args&&...);
 25 | 
 26 |  
 27 | #include <string>
 28 | #include <type_traits>
 29 | #include <swl_assert.hpp> 
 30 | #include <swl/variant.hpp> 
 31 | 
 32 | #include "test_convertible.h"
 33 | #include "test_macros.h"
 34 | 
 35 | struct InitList {
 36 |   std::size_t size;
 37 |   constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
 38 | };
 39 | 
 40 | struct InitListArg {
 41 |   std::size_t size;
 42 |   int value;
 43 |   constexpr InitListArg(std::initializer_list<int> il, int v)
 44 |       : size(il.size()), value(v) {}
 45 | };
 46 | 
 47 | void test_ctor_sfinae() {
 48 |   using IL = std::initializer_list<int>;
 49 |   { // just init list
 50 |     using V = swl::variant<InitList, InitListArg, int>;
 51 |     static_assert(
 52 |         std::is_constructible<V, swl::in_place_type_t<InitList>, IL>::value,
 53 |         "");
 54 |     static_assert(!test_convertible<V, swl::in_place_type_t<InitList>, IL>(),
 55 |                   "");
 56 |   }
 57 |   { // too many arguments
 58 |     using V = swl::variant<InitList, InitListArg, int>;
 59 |     static_assert(!std::is_constructible<V, swl::in_place_type_t<InitList>, IL,
 60 |                                          int>::value,
 61 |                   "");
 62 |     static_assert(
 63 |         !test_convertible<V, swl::in_place_type_t<InitList>, IL, int>(), "");
 64 |   }
 65 |   { // too few arguments
 66 |     using V = swl::variant<InitList, InitListArg, int>;
 67 |     static_assert(
 68 |         !std::is_constructible<V, swl::in_place_type_t<InitListArg>, IL>::value,
 69 |         "");
 70 |     static_assert(!test_convertible<V, swl::in_place_type_t<InitListArg>, IL>(),
 71 |                   "");
 72 |   }
 73 |   { // init list and arguments
 74 |     using V = swl::variant<InitList, InitListArg, int>;
 75 |     static_assert(std::is_constructible<V, swl::in_place_type_t<InitListArg>,
 76 |                                         IL, int>::value,
 77 |                   "");
 78 |     static_assert(
 79 |         !test_convertible<V, swl::in_place_type_t<InitListArg>, IL, int>(), "");
 80 |   }
 81 |   { // not constructible from arguments
 82 |     using V = swl::variant<InitList, InitListArg, int>;
 83 |     static_assert(
 84 |         !std::is_constructible<V, swl::in_place_type_t<int>, IL>::value, "");
 85 |     static_assert(!test_convertible<V, swl::in_place_type_t<int>, IL>(), "");
 86 |   }
 87 |   { // duplicate types in variant
 88 |     using V = swl::variant<InitListArg, InitListArg, int>;
 89 |     static_assert(!std::is_constructible<V, swl::in_place_type_t<InitListArg>,
 90 |                                          IL, int>::value,
 91 |                   "");
 92 |     static_assert(
 93 |         !test_convertible<V, swl::in_place_type_t<InitListArg>, IL, int>(), "");
 94 |   }
 95 | }
 96 | 
 97 | void test_ctor_basic() {
 98 |   {
 99 |     constexpr swl::variant<InitList, InitListArg> v(
100 |         swl::in_place_type<InitList>, {1, 2, 3});
101 |     static_assert(v.index() == 0, "");
102 |     static_assert(swl::get<0>(v).size == 3, "");
103 |   }
104 |   {
105 |     constexpr swl::variant<InitList, InitListArg> v(
106 |         swl::in_place_type<InitListArg>, {1, 2, 3, 4}, 42);
107 |     static_assert(v.index() == 1, "");
108 |     static_assert(swl::get<1>(v).size == 4, "");
109 |     static_assert(swl::get<1>(v).value == 42, "");
110 |   }
111 | }
112 | 
113 | int main(int, char**) {
114 |   test_ctor_basic();
115 |   test_ctor_sfinae();
116 | 
117 |   SWL_END_TEST_SIGNAL 
118 |  return 0; 
119 | 
120 | }
121 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.ctor/move.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // variant(variant&&) noexcept(see below); // constexpr in C++20
 23 | 
 24 |  
 25 | #include <string>
 26 | #include <type_traits>
 27 | #include <swl_assert.hpp> 
 28 | #include <swl/variant.hpp> 
 29 | 
 30 | #include "test_macros.h"
 31 | #include "test_workarounds.h"
 32 | 
 33 | struct ThrowsMove {
 34 |   ThrowsMove(ThrowsMove &&) noexcept(false) {}
 35 | };
 36 | 
 37 | struct NoCopy {
 38 |   NoCopy(const NoCopy &) = delete;
 39 | };
 40 | 
 41 | struct MoveOnly {
 42 |   int value;
 43 |   MoveOnly(int v) : value(v) {}
 44 |   MoveOnly(const MoveOnly &) = delete;
 45 |   MoveOnly(MoveOnly &&) = default;
 46 | };
 47 | 
 48 | struct MoveOnlyNT {
 49 |   int value;
 50 |   MoveOnlyNT(int v) : value(v) {}
 51 |   MoveOnlyNT(const MoveOnlyNT &) = delete;
 52 |   MoveOnlyNT(MoveOnlyNT &&other) : value(other.value) { other.value = -1; }
 53 | };
 54 | 
 55 | struct NTMove {
 56 |   constexpr NTMove(int v) : value(v) {}
 57 |   NTMove(const NTMove &) = delete;
 58 |   NTMove(NTMove &&that) : value(that.value) { that.value = -1; }
 59 |   int value;
 60 | };
 61 | 
 62 | static_assert(!std::is_trivially_move_constructible<NTMove>::value, "");
 63 | static_assert(std::is_move_constructible<NTMove>::value, "");
 64 | 
 65 | struct TMove {
 66 |   constexpr TMove(int v) : value(v) {}
 67 |   TMove(const TMove &) = delete;
 68 |   TMove(TMove &&) = default;
 69 |   int value;
 70 | };
 71 | 
 72 | static_assert(std::is_trivially_move_constructible<TMove>::value, "");
 73 | 
 74 | struct TMoveNTCopy {
 75 |   constexpr TMoveNTCopy(int v) : value(v) {}
 76 |   TMoveNTCopy(const TMoveNTCopy& that) : value(that.value) {}
 77 |   TMoveNTCopy(TMoveNTCopy&&) = default;
 78 |   int value;
 79 | };
 80 | 
 81 | static_assert(std::is_trivially_move_constructible<TMoveNTCopy>::value, "");
 82 | 
 83 | #ifndef TEST_HAS_NO_EXCEPTIONS
 84 | struct MakeEmptyT {
 85 |   static int alive;
 86 |   MakeEmptyT() { ++alive; }
 87 |   MakeEmptyT(const MakeEmptyT &) {
 88 |     ++alive;
 89 |     // Don't throw from the copy constructor since variant's assignment
 90 |     // operator performs a copy before committing to the assignment.
 91 |   }
 92 |   MakeEmptyT(MakeEmptyT &&) { throw 42; }
 93 |   MakeEmptyT &operator=(const MakeEmptyT &) { throw 42; }
 94 |   MakeEmptyT &operator=(MakeEmptyT &&) { throw 42; }
 95 |   ~MakeEmptyT() { --alive; }
 96 | };
 97 | 
 98 | int MakeEmptyT::alive = 0;
 99 | 
100 | template <class Variant> void makeEmpty(Variant &v) {
101 |   Variant v2(swl::in_place_type<MakeEmptyT>);
102 |   try {
103 |     v = std::move(v2);
104 |     SWL_ASSERT(false);
105 |   } catch (...) {
106 |     SWL_ASSERT(v.valueless_by_exception());
107 |   }
108 | }
109 | #endif // TEST_HAS_NO_EXCEPTIONS
110 | 
111 | void test_move_noexcept() {
112 |   {
113 |     using V = swl::variant<int, long>;
114 |     static_assert(std::is_nothrow_move_constructible<V>::value, "");
115 |   }
116 |   {
117 |     using V = swl::variant<int, MoveOnly>;
118 |     static_assert(std::is_nothrow_move_constructible<V>::value, "");
119 |   }
120 |   {
121 |     using V = swl::variant<int, MoveOnlyNT>;
122 |     static_assert(!std::is_nothrow_move_constructible<V>::value, "");
123 |   }
124 |   {
125 |     using V = swl::variant<int, ThrowsMove>;
126 |     static_assert(!std::is_nothrow_move_constructible<V>::value, "");
127 |   }
128 | }
129 | 
130 | void test_move_ctor_sfinae() {
131 |   {
132 |     using V = swl::variant<int, long>;
133 |     static_assert(std::is_move_constructible<V>::value, "");
134 |   }
135 |   {
136 |     using V = swl::variant<int, MoveOnly>;
137 |     static_assert(std::is_move_constructible<V>::value, "");
138 |   }
139 |   {
140 |     using V = swl::variant<int, MoveOnlyNT>;
141 |     static_assert(std::is_move_constructible<V>::value, "");
142 |   }
143 |   {
144 |     using V = swl::variant<int, NoCopy>;
145 |     static_assert(!std::is_move_constructible<V>::value, "");
146 |   }
147 | 
148 |   // Make sure we properly propagate triviality (see P0602R4).
149 | #if TEST_STD_VER > 17
150 |   {
151 |     using V = swl::variant<int, long>;
152 |     static_assert(std::is_trivially_move_constructible<V>::value, "");
153 |   }
154 |   {
155 |     using V = swl::variant<int, NTMove>;
156 |     static_assert(!std::is_trivially_move_constructible<V>::value, "");
157 |     static_assert(std::is_move_constructible<V>::value, "");
158 |   }
159 |   {
160 |     using V = swl::variant<int, TMove>;
161 |     static_assert(std::is_trivially_move_constructible<V>::value, "");
162 |   }
163 |   {
164 |     using V = swl::variant<int, TMoveNTCopy>;
165 |     static_assert(std::is_trivially_move_constructible<V>::value, "");
166 |   }
167 | #endif // > C++17
168 | }
169 | 
170 | template <typename T>
171 | struct Result { size_t index; T value; };
172 | 
173 | void test_move_ctor_basic() {
174 |   {
175 |     swl::variant<int> v(swl::in_place_index<0>, 42);
176 |     swl::variant<int> v2 = std::move(v);
177 |     SWL_ASSERT(v2.index() == 0);
178 |     SWL_ASSERT(swl::get<0>(v2) == 42);
179 |   }
180 |   {
181 |     swl::variant<int, long> v(swl::in_place_index<1>, 42);
182 |     swl::variant<int, long> v2 = std::move(v);
183 |     SWL_ASSERT(v2.index() == 1);
184 |     SWL_ASSERT(swl::get<1>(v2) == 42);
185 |   }
186 |   {
187 |     swl::variant<MoveOnly> v(swl::in_place_index<0>, 42);
188 |     SWL_ASSERT(v.index() == 0);
189 |     swl::variant<MoveOnly> v2(std::move(v));
190 |     SWL_ASSERT(v2.index() == 0);
191 |     SWL_ASSERT(swl::get<0>(v2).value == 42);
192 |   }
193 |   {
194 |     swl::variant<int, MoveOnly> v(swl::in_place_index<1>, 42);
195 |     SWL_ASSERT(v.index() == 1);
196 |     swl::variant<int, MoveOnly> v2(std::move(v));
197 |     SWL_ASSERT(v2.index() == 1);
198 |     SWL_ASSERT(swl::get<1>(v2).value == 42);
199 |   }
200 |   {
201 |     swl::variant<MoveOnlyNT> v(swl::in_place_index<0>, 42);
202 |     SWL_ASSERT(v.index() == 0);
203 |     swl::variant<MoveOnlyNT> v2(std::move(v));
204 |     SWL_ASSERT(v2.index() == 0);
205 |     SWL_ASSERT(swl::get<0>(v).value == -1);
206 |     SWL_ASSERT(swl::get<0>(v2).value == 42);
207 |   }
208 |   {
209 |     swl::variant<int, MoveOnlyNT> v(swl::in_place_index<1>, 42);
210 |     SWL_ASSERT(v.index() == 1);
211 |     swl::variant<int, MoveOnlyNT> v2(std::move(v));
212 |     SWL_ASSERT(v2.index() == 1);
213 |     SWL_ASSERT(swl::get<1>(v).value == -1);
214 |     SWL_ASSERT(swl::get<1>(v2).value == 42);
215 |   }
216 | 
217 |   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
218 | #if TEST_STD_VER > 17
219 |   {
220 |     struct {
221 |       constexpr Result<int> operator()() const {
222 |         swl::variant<int> v(swl::in_place_index<0>, 42);
223 |         swl::variant<int> v2 = std::move(v);
224 |         return {v2.index(), swl::get<0>(std::move(v2))};
225 |       }
226 |     } test;
227 |     constexpr auto result = test();
228 |     static_assert(result.index == 0, "");
229 |     static_assert(result.value == 42, "");
230 |   }
231 |   {
232 |     struct {
233 |       constexpr Result<long> operator()() const {
234 |         swl::variant<int, long> v(swl::in_place_index<1>, 42);
235 |         swl::variant<int, long> v2 = std::move(v);
236 |         return {v2.index(), swl::get<1>(std::move(v2))};
237 |       }
238 |     } test;
239 |     constexpr auto result = test();
240 |     static_assert(result.index == 1, "");
241 |     static_assert(result.value == 42, "");
242 |   }
243 |   {
244 |     struct {
245 |       constexpr Result<TMove> operator()() const {
246 |         swl::variant<TMove> v(swl::in_place_index<0>, 42);
247 |         swl::variant<TMove> v2(std::move(v));
248 |         return {v2.index(), swl::get<0>(std::move(v2))};
249 |       }
250 |     } test;
251 |     constexpr auto result = test();
252 |     static_assert(result.index == 0, "");
253 |     static_assert(result.value.value == 42, "");
254 |   }
255 |   {
256 |     struct {
257 |       constexpr Result<TMove> operator()() const {
258 |         swl::variant<int, TMove> v(swl::in_place_index<1>, 42);
259 |         swl::variant<int, TMove> v2(std::move(v));
260 |         return {v2.index(), swl::get<1>(std::move(v2))};
261 |       }
262 |     } test;
263 |     constexpr auto result = test();
264 |     static_assert(result.index == 1, "");
265 |     static_assert(result.value.value == 42, "");
266 |   }
267 |   {
268 |     struct {
269 |       constexpr Result<TMoveNTCopy> operator()() const {
270 |         swl::variant<TMoveNTCopy> v(swl::in_place_index<0>, 42);
271 |         swl::variant<TMoveNTCopy> v2(std::move(v));
272 |         return {v2.index(), swl::get<0>(std::move(v2))};
273 |       }
274 |     } test;
275 |     constexpr auto result = test();
276 |     static_assert(result.index == 0, "");
277 |     static_assert(result.value.value == 42, "");
278 |   }
279 |   {
280 |     struct {
281 |       constexpr Result<TMoveNTCopy> operator()() const {
282 |         swl::variant<int, TMoveNTCopy> v(swl::in_place_index<1>, 42);
283 |         swl::variant<int, TMoveNTCopy> v2(std::move(v));
284 |         return {v2.index(), swl::get<1>(std::move(v2))};
285 |       }
286 |     } test;
287 |     constexpr auto result = test();
288 |     static_assert(result.index == 1, "");
289 |     static_assert(result.value.value == 42, "");
290 |   }
291 | #endif // > C++17
292 | }
293 | 
294 | void test_move_ctor_valueless_by_exception() {
295 | #ifndef TEST_HAS_NO_EXCEPTIONS
296 |   using V = swl::variant<int, MakeEmptyT>;
297 |   V v1;
298 |   makeEmpty(v1);
299 |   V v(std::move(v1));
300 |   SWL_ASSERT(v.valueless_by_exception());
301 | #endif // TEST_HAS_NO_EXCEPTIONS
302 | }
303 | 
304 | template <size_t Idx>
305 | constexpr bool test_constexpr_ctor_imp(swl::variant<long, void*, const int> const& v) {
306 |   auto copy = v;
307 |   auto v2 = std::move(copy);
308 |   return v2.index() == v.index() &&
309 |          v2.index() == Idx &&
310 |         swl::get<Idx>(v2) == swl::get<Idx>(v);
311 | }
312 | 
313 | void test_constexpr_move_ctor() {
314 |   // Make sure we properly propagate triviality, which implies constexpr-ness (see P0602R4).
315 | #if TEST_STD_VER > 17
316 |   using V = swl::variant<long, void*, const int>;
317 | #ifdef TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
318 |   static_assert(std::is_trivially_destructible<V>::value, "");
319 |   static_assert(std::is_trivially_copy_constructible<V>::value, "");
320 |   static_assert(std::is_trivially_move_constructible<V>::value, "");
321 |   static_assert(!std::is_copy_assignable<V>::value, "");
322 |   static_assert(!std::is_move_assignable<V>::value, "");
323 | #else // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
324 | 	
325 |   // SWL-FIXME : disabling this for the same reason as the other one in copy test
326 |   // static_assert(std::is_trivially_copyable<V>::value, "");
327 | #endif // TEST_WORKAROUND_C1XX_BROKEN_IS_TRIVIALLY_COPYABLE
328 |   static_assert(std::is_trivially_move_constructible<V>::value, "");
329 |   static_assert(test_constexpr_ctor_imp<0>(V(42l)), "");
330 |   static_assert(test_constexpr_ctor_imp<1>(V(nullptr)), "");
331 |   static_assert(test_constexpr_ctor_imp<2>(V(101)), "");
332 | #endif // > C++17
333 | }
334 | 
335 | 
336 | int main(int, char**) {
337 |   test_move_ctor_basic();
338 |   test_move_ctor_valueless_by_exception();
339 |   test_move_noexcept();
340 |   test_move_ctor_sfinae();
341 |   test_constexpr_move_ctor();
342 | 
343 |   SWL_END_TEST_SIGNAL 
344 |  return 0; 
345 | 
346 | }
347 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.dtor/dtor.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | // ~variant();
17 | 
18 |  
19 | #include <type_traits>
20 | #include <swl_assert.hpp> 
21 | #include <swl/variant.hpp> 
22 | 
23 | #include "test_macros.h"
24 | 
25 | struct NonTDtor {
26 |   static int count;
27 |   NonTDtor() = default;
28 |   ~NonTDtor() { ++count; }
29 | };
30 | int NonTDtor::count = 0;
31 | static_assert(!std::is_trivially_destructible<NonTDtor>::value, "");
32 | 
33 | struct NonTDtor1 {
34 |   static int count;
35 |   NonTDtor1() = default;
36 |   ~NonTDtor1() { ++count; }
37 | };
38 | int NonTDtor1::count = 0;
39 | static_assert(!std::is_trivially_destructible<NonTDtor1>::value, "");
40 | 
41 | struct TDtor {
42 |   TDtor(const TDtor &) {} // non-trivial copy
43 |   ~TDtor() = default;
44 | };
45 | static_assert(!std::is_trivially_copy_constructible<TDtor>::value, "");
46 | static_assert(std::is_trivially_destructible<TDtor>::value, "");
47 | 
48 | int main(int, char**) {
49 |   {
50 |     using V = swl::variant<int, long, TDtor>;
51 |     static_assert(std::is_trivially_destructible<V>::value, "");
52 |   }
53 |   {
54 |     using V = swl::variant<NonTDtor, int, NonTDtor1>;
55 |     static_assert(!std::is_trivially_destructible<V>::value, "");
56 |     {
57 |       V v(swl::in_place_index<0>);
58 |       SWL_ASSERT(NonTDtor::count == 0);
59 |       SWL_ASSERT(NonTDtor1::count == 0);
60 |     }
61 |     SWL_ASSERT(NonTDtor::count == 1);
62 |     SWL_ASSERT(NonTDtor1::count == 0);
63 |     NonTDtor::count = 0;
64 |     { V v(swl::in_place_index<1>); }
65 |     SWL_ASSERT(NonTDtor::count == 0);
66 |     SWL_ASSERT(NonTDtor1::count == 0);
67 |     {
68 |       V v(swl::in_place_index<2>);
69 |       SWL_ASSERT(NonTDtor::count == 0);
70 |       SWL_ASSERT(NonTDtor1::count == 0);
71 |     }
72 |     SWL_ASSERT(NonTDtor::count == 0);
73 |     SWL_ASSERT(NonTDtor1::count == 1);
74 |   }
75 | 
76 |   SWL_END_TEST_SIGNAL 
77 |  return 0; 
78 | 
79 | }
80 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.mod/emplace_index_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <size_t I, class ...Args>
 23 | //   variant_alternative_t<I, variant<Types...>>& emplace(Args&&... args);
 24 | 
 25 |  
 26 | #include <string>
 27 | #include <type_traits>
 28 | #include <swl_assert.hpp> 
 29 | #include <swl/variant.hpp> 
 30 | 
 31 | #include "archetypes.h"
 32 | #include "test_convertible.h"
 33 | #include "test_macros.h"
 34 | #include "variant_test_helpers.h"
 35 | 
 36 | template <class Var, size_t I, class... Args>
 37 | constexpr auto test_emplace_exists_imp(int) -> decltype(
 38 |     std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
 39 |   return true;
 40 | }
 41 | 
 42 | template <class, size_t, class...>
 43 | constexpr auto test_emplace_exists_imp(long) -> bool {
 44 |   return false;
 45 | }
 46 | 
 47 | template <class Var, size_t I, class... Args> constexpr bool emplace_exists() {
 48 |   return test_emplace_exists_imp<Var, I, Args...>(0);
 49 | }
 50 | 
 51 | void test_emplace_sfinae() {
 52 |   {
 53 |     using V = swl::variant<int, void *, const void *, TestTypes::NoCtors>;
 54 |     static_assert(emplace_exists<V, 0>(), "");
 55 |     static_assert(emplace_exists<V, 0, int>(), "");
 56 |     static_assert(!emplace_exists<V, 0, decltype(nullptr)>(),
 57 |                   "cannot construct");
 58 |     static_assert(emplace_exists<V, 1, decltype(nullptr)>(), "");
 59 |     static_assert(emplace_exists<V, 1, int *>(), "");
 60 |     static_assert(!emplace_exists<V, 1, const int *>(), "");
 61 |     static_assert(!emplace_exists<V, 1, int>(), "cannot construct");
 62 |     static_assert(emplace_exists<V, 2, const int *>(), "");
 63 |     static_assert(emplace_exists<V, 2, int *>(), "");
 64 |     static_assert(!emplace_exists<V, 3>(), "cannot construct");
 65 |   }
 66 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 67 |   {
 68 |     using V = swl::variant<int, int &, const int &, int &&, TestTypes::NoCtors>;
 69 |     static_assert(emplace_exists<V, 0>(), "");
 70 |     static_assert(emplace_exists<V, 0, int>(), "");
 71 |     static_assert(emplace_exists<V, 0, long long>(), "");
 72 |     static_assert(!emplace_exists<V, 0, int, int>(), "too many args");
 73 |     static_assert(emplace_exists<V, 1, int &>(), "");
 74 |     static_assert(!emplace_exists<V, 1>(), "cannot default construct ref");
 75 |     static_assert(!emplace_exists<V, 1, const int &>(), "cannot bind ref");
 76 |     static_assert(!emplace_exists<V, 1, int &&>(), "cannot bind ref");
 77 |     static_assert(emplace_exists<V, 2, int &>(), "");
 78 |     static_assert(emplace_exists<V, 2, const int &>(), "");
 79 |     static_assert(emplace_exists<V, 2, int &&>(), "");
 80 |     static_assert(!emplace_exists<V, 2, void *>(),
 81 |                   "not constructible from void*");
 82 |     static_assert(emplace_exists<V, 3, int>(), "");
 83 |     static_assert(!emplace_exists<V, 3, int &>(), "cannot bind ref");
 84 |     static_assert(!emplace_exists<V, 3, const int &>(), "cannot bind ref");
 85 |     static_assert(!emplace_exists<V, 3, const int &&>(), "cannot bind ref");
 86 |     static_assert(!emplace_exists<V, 4>(), "no ctors");
 87 |   }
 88 | #endif
 89 | }
 90 | 
 91 | void test_basic() {
 92 |   {
 93 |     using V = swl::variant<int>;
 94 |     V v(42);
 95 |     auto& ref1 = v.emplace<0>();
 96 |     static_assert(std::is_same_v<int&, decltype(ref1)>, "");
 97 |     SWL_ASSERT(swl::get<0>(v) == 0);
 98 |     SWL_ASSERT(&ref1 == &swl::get<0>(v));
 99 |     auto& ref2 = v.emplace<0>(42);
100 |     static_assert(std::is_same_v<int&, decltype(ref2)>, "");
101 |     SWL_ASSERT(swl::get<0>(v) == 42);
102 |     SWL_ASSERT(&ref2 == &swl::get<0>(v));
103 |   }
104 |   {
105 |     using V =
106 |         swl::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
107 |     const int x = 100;
108 |     V v(swl::in_place_index<0>, -1);
109 |     // default emplace a value
110 |     auto& ref1 = v.emplace<1>();
111 |     static_assert(std::is_same_v<long&, decltype(ref1)>, "");
112 |     SWL_ASSERT(swl::get<1>(v) == 0);
113 |     SWL_ASSERT(&ref1 == &swl::get<1>(v));
114 |     auto& ref2 = v.emplace<2>(&x);
115 |     static_assert(std::is_same_v<const void*&, decltype(ref2)>, "");
116 |     SWL_ASSERT(swl::get<2>(v) == &x);
117 |     SWL_ASSERT(&ref2 == &swl::get<2>(v));
118 |     // emplace with multiple args
119 |     auto& ref3 = v.emplace<4>(3u, 'a');
120 |     static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
121 |     SWL_ASSERT(swl::get<4>(v) == "aaa");
122 |     SWL_ASSERT(&ref3 == &swl::get<4>(v));
123 |   }
124 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
125 |   {
126 |     using V = swl::variant<int, long, const int &, int &&, TestTypes::NoCtors,
127 |                            std::string>;
128 |     const int x = 100;
129 |     int y = 42;
130 |     int z = 43;
131 |     V v(swl::in_place_index<0>, -1);
132 |     // default emplace a value
133 |     auto& ref1 = v.emplace<1>();
134 |     static_assert(std::is_same_v<long&, decltype(ref1)>, "");
135 |     SWL_ASSERT(swl::get<1>(v) == 0);
136 |     SWL_ASSERT(&ref1 == &swl::get<1>(v));
137 |     // emplace a reference
138 |     auto& ref2 = v.emplace<2>(x);
139 |     static_assert(std::is_same_v<&, decltype(ref)>, "");
140 |     SWL_ASSERT(&swl::get<2>(v) == &x);
141 |     SWL_ASSERT(&ref2 == &swl::get<2>(v));
142 |     // emplace an rvalue reference
143 |     auto& ref3 = v.emplace<3>(std::move(y));
144 |     static_assert(std::is_same_v<&, decltype(ref)>, "");
145 |     SWL_ASSERT(&swl::get<3>(v) == &y);
146 |     SWL_ASSERT(&ref3 == &swl::get<3>(v));
147 |     // re-emplace a new reference over the active member
148 |     auto& ref4 = v.emplace<3>(std::move(z));
149 |     static_assert(std::is_same_v<&, decltype(ref)>, "");
150 |     SWL_ASSERT(&swl::get<3>(v) == &z);
151 |     SWL_ASSERT(&ref4 == &swl::get<3>(v));
152 |     // emplace with multiple args
153 |     auto& ref5 = v.emplace<5>(3u, 'a');
154 |     static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
155 |     SWL_ASSERT(swl::get<5>(v) == "aaa");
156 |     SWL_ASSERT(&ref5 == &swl::get<5>(v));
157 |   }
158 | #endif
159 | }
160 | 
161 | int main(int, char**) {
162 |   test_basic();
163 |   test_emplace_sfinae();
164 | 
165 |   SWL_END_TEST_SIGNAL 
166 |  return 0; 
167 | 
168 | }
169 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.mod/emplace_index_init_list_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <size_t I, class U, class ...Args>
 23 | //   variant_alternative_t<I, variant<Types...>>& emplace(initializer_list<U> il,Args&&... args);
 24 | 
 25 |  
 26 | #include <string>
 27 | #include <type_traits>
 28 | #include <swl_assert.hpp> 
 29 | #include <swl/variant.hpp> 
 30 | 
 31 | #include "archetypes.h"
 32 | #include "test_convertible.h"
 33 | #include "test_macros.h"
 34 | 
 35 | struct InitList {
 36 |   std::size_t size;
 37 |   constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
 38 | };
 39 | 
 40 | struct InitListArg {
 41 |   std::size_t size;
 42 |   int value;
 43 |   constexpr InitListArg(std::initializer_list<int> il, int v)
 44 |       : size(il.size()), value(v) {}
 45 | };
 46 | 
 47 | template <class Var, size_t I, class... Args>
 48 | constexpr auto test_emplace_exists_imp(int) -> decltype(
 49 |     std::declval<Var>().template emplace<I>(std::declval<Args>()...), true) {
 50 |   return true;
 51 | }
 52 | 
 53 | template <class, size_t, class...>
 54 | constexpr auto test_emplace_exists_imp(long) -> bool {
 55 |   return false;
 56 | }
 57 | 
 58 | template <class Var, size_t I, class... Args> constexpr bool emplace_exists() {
 59 |   return test_emplace_exists_imp<Var, I, Args...>(0);
 60 | }
 61 | 
 62 | void test_emplace_sfinae() {
 63 |   using V =
 64 |       swl::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
 65 |   using IL = std::initializer_list<int>;
 66 |   static_assert(!emplace_exists<V, 1, IL>(), "no such constructor");
 67 |   static_assert(emplace_exists<V, 2, IL>(), "");
 68 |   static_assert(!emplace_exists<V, 2, int>(), "args don't match");
 69 |   static_assert(!emplace_exists<V, 2, IL, int>(), "too many args");
 70 |   static_assert(emplace_exists<V, 3, IL, int>(), "");
 71 |   static_assert(!emplace_exists<V, 3, int>(), "args don't match");
 72 |   static_assert(!emplace_exists<V, 3, IL>(), "too few args");
 73 |   static_assert(!emplace_exists<V, 3, IL, int, int>(), "too many args");
 74 | }
 75 | 
 76 | void test_basic() {
 77 |   using V = swl::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
 78 |   V v;
 79 |   auto& ref1 = v.emplace<1>({1, 2, 3});
 80 |   static_assert(std::is_same_v<InitList&, decltype(ref1)>, "");
 81 |   SWL_ASSERT(swl::get<1>(v).size == 3);
 82 |   SWL_ASSERT(&ref1 == &swl::get<1>(v));
 83 |   auto& ref2 = v.emplace<2>({1, 2, 3, 4}, 42);
 84 |   static_assert(std::is_same_v<InitListArg&, decltype(ref2)>, "");
 85 |   SWL_ASSERT(swl::get<2>(v).size == 4);
 86 |   SWL_ASSERT(swl::get<2>(v).value == 42);
 87 |   SWL_ASSERT(&ref2 == &swl::get<2>(v));
 88 |   auto& ref3 = v.emplace<1>({1});
 89 |   static_assert(std::is_same_v<InitList&, decltype(ref3)>, "");
 90 |   SWL_ASSERT(swl::get<1>(v).size == 1);
 91 |   SWL_ASSERT(&ref3 == &swl::get<1>(v));
 92 | }
 93 | 
 94 | int main(int, char**) {
 95 |   test_basic();
 96 |   test_emplace_sfinae();
 97 | 
 98 |   SWL_END_TEST_SIGNAL 
 99 |  return 0; 
100 | 
101 | }
102 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.mod/emplace_type_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class T, class ...Args> T& emplace(Args&&... args);
 23 | 
 24 |  
 25 | #include <string>
 26 | #include <type_traits>
 27 | #include <swl_assert.hpp> 
 28 | #include <swl/variant.hpp> 
 29 | 
 30 | #include "archetypes.h"
 31 | #include "test_convertible.h"
 32 | #include "test_macros.h"
 33 | #include "variant_test_helpers.h"
 34 | 
 35 | template <class Var, class T, class... Args>
 36 | constexpr auto test_emplace_exists_imp(int) -> decltype(
 37 |     std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
 38 |   return true;
 39 | }
 40 | 
 41 | template <class, class, class...>
 42 | constexpr auto test_emplace_exists_imp(long) -> bool {
 43 |   return false;
 44 | }
 45 | 
 46 | template <class... Args> constexpr bool emplace_exists() {
 47 |   return test_emplace_exists_imp<Args...>(0);
 48 | }
 49 | 
 50 | void test_emplace_sfinae() {
 51 |   {
 52 |     using V = swl::variant<int, void *, const void *, TestTypes::NoCtors>;
 53 |     static_assert(emplace_exists<V, int>(), "");
 54 |     static_assert(emplace_exists<V, int, int>(), "");
 55 |     static_assert(!emplace_exists<V, int, decltype(nullptr)>(),
 56 |                   "cannot construct");
 57 |     static_assert(emplace_exists<V, void *, decltype(nullptr)>(), "");
 58 |     static_assert(!emplace_exists<V, void *, int>(), "cannot construct");
 59 |     static_assert(emplace_exists<V, void *, int *>(), "");
 60 |     static_assert(!emplace_exists<V, void *, const int *>(), "");
 61 |     static_assert(emplace_exists<V, const void *, const int *>(), "");
 62 |     static_assert(emplace_exists<V, const void *, int *>(), "");
 63 |     static_assert(!emplace_exists<V, TestTypes::NoCtors>(), "cannot construct");
 64 |   }
 65 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
 66 |   using V = swl::variant<int, int &, const int &, int &&, long, long,
 67 |                          TestTypes::NoCtors>;
 68 |   static_assert(emplace_exists<V, int>(), "");
 69 |   static_assert(emplace_exists<V, int, int>(), "");
 70 |   static_assert(emplace_exists<V, int, long long>(), "");
 71 |   static_assert(!emplace_exists<V, int, int, int>(), "too many args");
 72 |   static_assert(emplace_exists<V, int &, int &>(), "");
 73 |   static_assert(!emplace_exists<V, int &>(), "cannot default construct ref");
 74 |   static_assert(!emplace_exists<V, int &, const int &>(), "cannot bind ref");
 75 |   static_assert(!emplace_exists<V, int &, int &&>(), "cannot bind ref");
 76 |   static_assert(emplace_exists<V, const int &, int &>(), "");
 77 |   static_assert(emplace_exists<V, const int &, const int &>(), "");
 78 |   static_assert(emplace_exists<V, const int &, int &&>(), "");
 79 |   static_assert(!emplace_exists<V, const int &, void *>(),
 80 |                 "not constructible from void*");
 81 |   static_assert(emplace_exists<V, int &&, int>(), "");
 82 |   static_assert(!emplace_exists<V, int &&, int &>(), "cannot bind ref");
 83 |   static_assert(!emplace_exists<V, int &&, const int &>(), "cannot bind ref");
 84 |   static_assert(!emplace_exists<V, int &&, const int &&>(), "cannot bind ref");
 85 |   static_assert(!emplace_exists<V, long, long>(), "ambiguous");
 86 |   static_assert(!emplace_exists<V, TestTypes::NoCtors>(),
 87 |                 "cannot construct void");
 88 | #endif
 89 | }
 90 | 
 91 | void test_basic() {
 92 |   {
 93 |     using V = swl::variant<int>;
 94 |     V v(42);
 95 |     auto& ref1 = v.emplace<int>();
 96 |     static_assert(std::is_same_v<int&, decltype(ref1)>, "");
 97 |     SWL_ASSERT(swl::get<0>(v) == 0);
 98 |     SWL_ASSERT(&ref1 == &swl::get<0>(v));
 99 |     auto& ref2 = v.emplace<int>(42);
100 |     static_assert(std::is_same_v<int&, decltype(ref2)>, "");
101 |     SWL_ASSERT(swl::get<0>(v) == 42);
102 |     SWL_ASSERT(&ref2 == &swl::get<0>(v));
103 |   }
104 |   {
105 |     using V =
106 |         swl::variant<int, long, const void *, TestTypes::NoCtors, std::string>;
107 |     const int x = 100;
108 |     V v(swl::in_place_type<int>, -1);
109 |     // default emplace a value
110 |     auto& ref1 = v.emplace<long>();
111 |     static_assert(std::is_same_v<long&, decltype(ref1)>, "");
112 |     SWL_ASSERT(swl::get<1>(v) == 0);
113 |     SWL_ASSERT(&ref1 == &swl::get<1>(v));
114 |     auto& ref2 = v.emplace<const void *>(&x);
115 |     static_assert(std::is_same_v<const void *&, decltype(ref2)>, "");
116 |     SWL_ASSERT(swl::get<2>(v) == &x);
117 |     SWL_ASSERT(&ref2 == &swl::get<2>(v));
118 |     // emplace with multiple args
119 |     auto& ref3 = v.emplace<std::string>(3u, 'a');
120 |     static_assert(std::is_same_v<std::string&, decltype(ref3)>, "");
121 |     SWL_ASSERT(swl::get<4>(v) == "aaa");
122 |     SWL_ASSERT(&ref3 == &swl::get<4>(v));
123 |   }
124 | #if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
125 |   {
126 |     using V = swl::variant<int, long, const int &, int &&, TestTypes::NoCtors,
127 |                            std::string>;
128 |     const int x = 100;
129 |     int y = 42;
130 |     int z = 43;
131 |     V v(swl::in_place_index<0>, -1);
132 |     // default emplace a value
133 |     auto& ref1 = v.emplace<long>();
134 |     static_assert(std::is_same_v<long&, decltype(ref1)>, "");
135 |     SWL_ASSERT(swl::get<long>(v) == 0);
136 |     SWL_ASSERT(&ref1 == &swl::get<long>(v));
137 |     // emplace a reference
138 |     auto& ref2 = v.emplace<const int &>(x);
139 |     static_assert(std::is_same_v<const int&, decltype(ref2)>, "");
140 |     SWL_ASSERT(&swl::get<const int &>(v) == &x);
141 |     SWL_ASSERT(&ref2 == &swl::get<const int &>(v));
142 |     // emplace an rvalue reference
143 |     auto& ref3 = v.emplace<int &&>(std::move(y));
144 |     static_assert(std::is_same_v<int &&, decltype(ref3)>, "");
145 |     SWL_ASSERT(&swl::get<int &&>(v) == &y);
146 |     SWL_ASSERT(&ref3 == &swl::get<int &&>(v));
147 |     // re-emplace a new reference over the active member
148 |     auto& ref4 = v.emplace<int &&>(std::move(z));
149 |     static_assert(std::is_same_v<int &, decltype(ref4)>, "");
150 |     SWL_ASSERT(&swl::get<int &&>(v) == &z);
151 |     SWL_ASSERT(&ref4 == &swl::get<int &&>(v));
152 |     // emplace with multiple args
153 |     auto& ref5 = v.emplace<std::string>(3u, 'a');
154 |     static_assert(std::is_same_v<std::string&, decltype(ref5)>, "");
155 |     SWL_ASSERT(swl::get<std::string>(v) == "aaa");
156 |     SWL_ASSERT(&ref5 == &swl::get<std::string>(v));
157 |   }
158 | #endif
159 | }
160 | 
161 | int main(int, char**) {
162 |   test_basic();
163 |   test_emplace_sfinae();
164 | 
165 |   SWL_END_TEST_SIGNAL 
166 |  return 0; 
167 | 
168 | }
169 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.mod/emplace_type_init_list_args.pass.cpp:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | 
 10 | // UNSUPPORTED: c++03, c++11, c++14
 11 | 
 12 | // Throwing bad_variant_access is supported starting in macosx10.13
 13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
 14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
 15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
 16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
 17 | 
 18 | // <variant>
 19 | 
 20 | // template <class ...Types> class variant;
 21 | 
 22 | // template <class T, class U, class ...Args>
 23 | //   T& emplace(initializer_list<U> il,Args&&... args);
 24 | 
 25 |  
 26 | #include <string>
 27 | #include <type_traits>
 28 | #include <swl_assert.hpp> 
 29 | #include <swl/variant.hpp> 
 30 | 
 31 | #include "archetypes.h"
 32 | #include "test_convertible.h"
 33 | #include "test_macros.h"
 34 | 
 35 | struct InitList {
 36 |   std::size_t size;
 37 |   constexpr InitList(std::initializer_list<int> il) : size(il.size()) {}
 38 | };
 39 | 
 40 | struct InitListArg {
 41 |   std::size_t size;
 42 |   int value;
 43 |   constexpr InitListArg(std::initializer_list<int> il, int v)
 44 |       : size(il.size()), value(v) {}
 45 | };
 46 | 
 47 | template <class Var, class T, class... Args>
 48 | constexpr auto test_emplace_exists_imp(int) -> decltype(
 49 |     std::declval<Var>().template emplace<T>(std::declval<Args>()...), true) {
 50 |   return true;
 51 | }
 52 | 
 53 | template <class, class, class...>
 54 | constexpr auto test_emplace_exists_imp(long) -> bool {
 55 |   return false;
 56 | }
 57 | 
 58 | template <class... Args> constexpr bool emplace_exists() {
 59 |   return test_emplace_exists_imp<Args...>(0);
 60 | }
 61 | 
 62 | void test_emplace_sfinae() {
 63 |   using V =
 64 |       swl::variant<int, TestTypes::NoCtors, InitList, InitListArg, long, long>;
 65 |   using IL = std::initializer_list<int>;
 66 |   static_assert(emplace_exists<V, InitList, IL>(), "");
 67 |   static_assert(!emplace_exists<V, InitList, int>(), "args don't match");
 68 |   static_assert(!emplace_exists<V, InitList, IL, int>(), "too many args");
 69 |   static_assert(emplace_exists<V, InitListArg, IL, int>(), "");
 70 |   static_assert(!emplace_exists<V, InitListArg, int>(), "args don't match");
 71 |   static_assert(!emplace_exists<V, InitListArg, IL>(), "too few args");
 72 |   static_assert(!emplace_exists<V, InitListArg, IL, int, int>(),
 73 |                 "too many args");
 74 | }
 75 | 
 76 | void test_basic() {
 77 |   using V = swl::variant<int, InitList, InitListArg, TestTypes::NoCtors>;
 78 |   V v;
 79 |   auto& ref1 = v.emplace<InitList>({1, 2, 3});
 80 |   static_assert(std::is_same_v<InitList&,decltype(ref1)>, "");
 81 |   SWL_ASSERT(swl::get<InitList>(v).size == 3);
 82 |   SWL_ASSERT(&ref1 == &swl::get<InitList>(v));
 83 |   auto& ref2 = v.emplace<InitListArg>({1, 2, 3, 4}, 42);
 84 |   static_assert(std::is_same_v<InitListArg&,decltype(ref2)>, "");
 85 |   SWL_ASSERT(swl::get<InitListArg>(v).size == 4);
 86 |   SWL_ASSERT(swl::get<InitListArg>(v).value == 42);
 87 |   SWL_ASSERT(&ref2 == &swl::get<InitListArg>(v));
 88 |   auto& ref3 = v.emplace<InitList>({1});
 89 |   static_assert(std::is_same_v<InitList&,decltype(ref3)>, "");
 90 |   SWL_ASSERT(swl::get<InitList>(v).size == 1);
 91 |   SWL_ASSERT(&ref3 == &swl::get<InitList>(v));
 92 | }
 93 | 
 94 | int main(int, char**) {
 95 |   test_basic();
 96 |   test_emplace_sfinae();
 97 | 
 98 |   SWL_END_TEST_SIGNAL 
 99 |  return 0; 
100 | 
101 | }
102 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.status/index.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | // constexpr size_t index() const noexcept;
17 | 
18 |  
19 | #include <string>
20 | #include <type_traits>
21 | #include <swl_assert.hpp> 
22 | #include <swl/variant.hpp> 
23 | 
24 | #include "archetypes.h"
25 | #include "test_macros.h"
26 | #include "variant_test_helpers.h"
27 | 
28 | 
29 | int main(int, char**) {
30 |   {
31 |     using V = swl::variant<int, long>;
32 |     constexpr V v;
33 |     static_assert(v.index() == 0, "");
34 |   }
35 |   {
36 |     using V = swl::variant<int, long>;
37 |     V v;
38 |     SWL_ASSERT(v.index() == 0);
39 |   }
40 |   {
41 |     using V = swl::variant<int, long>;
42 |     constexpr V v(swl::in_place_index<1>);
43 |     static_assert(v.index() == 1, "");
44 |   }
45 |   {
46 |     using V = swl::variant<int, std::string>;
47 |     V v("abc");
48 |     SWL_ASSERT(v.index() == 1);
49 |     v = 42;
50 |     SWL_ASSERT(v.index() == 0);
51 |   }
52 | #ifndef TEST_HAS_NO_EXCEPTIONS
53 |   {
54 |     using V = swl::variant<int, MakeEmptyT>;
55 |     V v;
56 |     SWL_ASSERT(v.index() == 0);
57 |     makeEmpty(v);
58 |     SWL_ASSERT(v.index() == swl::variant_npos);
59 |   }
60 | #endif
61 | 
62 |   SWL_END_TEST_SIGNAL 
63 |  return 0; 
64 | 
65 | }
66 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant.status/valueless_by_exception.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | // constexpr bool valueless_by_exception() const noexcept;
17 | 
18 |  
19 | #include <string>
20 | #include <type_traits>
21 | #include <swl_assert.hpp> 
22 | #include <swl/variant.hpp> 
23 | 
24 | #include "archetypes.h"
25 | #include "test_macros.h"
26 | #include "variant_test_helpers.h"
27 | 
28 | 
29 | int main(int, char**) {
30 |   {
31 |     using V = swl::variant<int, long>;
32 |     constexpr V v;
33 |     static_assert(!v.valueless_by_exception(), "");
34 |   }
35 |   {
36 |     using V = swl::variant<int, long>;
37 |     V v;
38 |     SWL_ASSERT(!v.valueless_by_exception());
39 |   }
40 |   {
41 |     using V = swl::variant<int, long, std::string>;
42 |     const V v("abc");
43 |     SWL_ASSERT(!v.valueless_by_exception());
44 |   }
45 | #ifndef TEST_HAS_NO_EXCEPTIONS
46 |   {
47 |     using V = swl::variant<int, MakeEmptyT>;
48 |     V v;
49 |     SWL_ASSERT(!v.valueless_by_exception());
50 |     makeEmpty(v);
51 |     SWL_ASSERT(v.valueless_by_exception());
52 |   }
53 | #endif
54 | 
55 |   SWL_END_TEST_SIGNAL 
56 |  return 0; 
57 | 
58 | }
59 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant_array.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | 
17 | #include <swl_assert.hpp> 
18 | #include <swl/variant.hpp> 
19 | #include <type_traits>
20 | #include <string>
21 |  
22 | 
23 | #include "test_macros.h"
24 | #include "variant_test_helpers.h"
25 | #include "test_convertible.h"
26 | 
27 | int main(int, char**)
28 | {
29 |     // expected-error@variant:* 3 {{static_assert failed}}
30 |     swl::variant<int, int[]> v; // expected-note {{requested here}}
31 |     swl::variant<int, int[42]> v2; // expected-note {{requested here}}
32 |     swl::variant<int, int[][42]> v3; // expected-note {{requested here}}
33 | 
34 |   SWL_END_TEST_SIGNAL 
35 |  return 0; 
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant_empty.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | #include <swl_assert.hpp> 
17 | #include <swl/variant.hpp> 
18 | 
19 | #include "test_macros.h"
20 | #include "variant_test_helpers.h"
21 | 
22 | int main(int, char**)
23 | {
24 |     // expected-error@variant:* 1 {{static_assert failed}}
25 |     swl::variant<> v; // expected-note {{requested here}}
26 | 
27 |   SWL_END_TEST_SIGNAL 
28 |  return 0; 
29 | 
30 | }
31 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant_reference.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | #include <swl_assert.hpp> 
17 | #include <swl/variant.hpp> 
18 | 
19 | #include "test_macros.h"
20 | #include "variant_test_helpers.h"
21 | 
22 | int main(int, char**)
23 | {
24 |     // expected-error@variant:* 3 {{static_assert failed}}
25 |     swl::variant<int, int&> v; // expected-note {{requested here}}
26 |     swl::variant<int, const int &> v2; // expected-note {{requested here}}
27 |     swl::variant<int, int&&> v3; // expected-note {{requested here}}
28 | 
29 |   SWL_END_TEST_SIGNAL 
30 |  return 0; 
31 | 
32 | }
33 | 


--------------------------------------------------------------------------------
/tests/tests/variant.variant/variant_void.fail.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // <variant>
13 | 
14 | // template <class ...Types> class variant;
15 | 
16 | 
17 | #include <swl_assert.hpp> 
18 | #include <swl/variant.hpp> 
19 | #include <type_traits>
20 | #include <string>
21 |  
22 | 
23 | #include "test_macros.h"
24 | #include "variant_test_helpers.h"
25 | #include "test_convertible.h"
26 | 
27 | int main(int, char**)
28 | {
29 |     // expected-error@variant:* 3 {{static_assert failed}}
30 |     swl::variant<int, void> v; // expected-note {{requested here}}
31 |     swl::variant<int, const void> v2; // expected-note {{requested here}}
32 |     swl::variant<const volatile void, int> v3; // expected-note {{requested here}}
33 | 
34 |   SWL_END_TEST_SIGNAL 
35 |  return 0; 
36 | 
37 | }
38 | 


--------------------------------------------------------------------------------
/tests/tests/variant.visit/robust_against_adl.pass.cpp:
--------------------------------------------------------------------------------
 1 | // -*- C++ -*-
 2 | //===----------------------------------------------------------------------===//
 3 | //
 4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 5 | // See https://llvm.org/LICENSE.txt for license information.
 6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 7 | //
 8 | //===----------------------------------------------------------------------===//
 9 | 
10 | // UNSUPPORTED: c++03, c++11, c++14
11 | 
12 | // Throwing bad_variant_access is supported starting in macosx10.13
13 | // XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
14 | // XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
15 | // XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
16 | // XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
17 | 
18 | // <variant>
19 | // template <class Visitor, class... Variants>
20 | // constexpr see below visit(Visitor&& vis, Variants&&... vars);
21 | 
22 | #include <swl_assert.hpp> 
23 | #include <swl/variant.hpp> 
24 | 
25 | #include "test_macros.h"
26 | 
27 | struct Incomplete;
28 | template<class T> struct Holder { T t; };
29 | 
30 | constexpr bool test(bool do_it)
31 | {
32 |     if (do_it) {
33 |         swl::variant<Holder<Incomplete>*, int> v = nullptr;
34 |         swl::visit([](auto){}, v);
35 |         swl::visit([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
36 | #if TEST_STD_VER > 17
37 |         swl::visit<void>([](auto){}, v);
38 |         swl::visit<void*>([](auto) -> Holder<Incomplete>* { return nullptr; }, v);
39 | #endif
40 |     }
41 |     return true;
42 | }
43 | 
44 | int main(int, char**)
45 | {
46 |     test(true);
47 | #if TEST_STD_VER > 17
48 |     static_assert(test(true));
49 | #endif
50 |     SWL_END_TEST_SIGNAL 
51 |  return 0; 
52 | 
53 | }
54 | 


--------------------------------------------------------------------------------
/tests/type_id.h:
--------------------------------------------------------------------------------
 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 | #ifndef SUPPORT_TYPE_ID_H
 9 | #define SUPPORT_TYPE_ID_H
10 | 
11 | #include <functional>
12 | #include <string>
13 | #include <cstdio>
14 | #include <cassert>
15 | 
16 | #include "test_macros.h"
17 | 
18 | #if TEST_STD_VER < 11
19 | #error This header requires C++11 or greater
20 | #endif
21 | 
22 | // TypeID - Represent a unique identifier for a type. TypeID allows equality
23 | // comparisons between different types.
24 | struct TypeID {
25 |   friend bool operator==(TypeID const& LHS, TypeID const& RHS)
26 |   {return LHS.m_id == RHS.m_id; }
27 |   friend bool operator!=(TypeID const& LHS, TypeID const& RHS)
28 |   {return LHS.m_id != RHS.m_id; }
29 | 
30 |   std::string name() const {
31 |     return m_id;
32 |   }
33 | 
34 | private:
35 |   explicit constexpr TypeID(const char* xid) : m_id(xid) {}
36 | 
37 |   TypeID(const TypeID&) = delete;
38 |   TypeID& operator=(TypeID const&) = delete;
39 | 
40 |   const char* const m_id;
41 |   template <class T> friend TypeID const& makeTypeIDImp();
42 | };
43 | 
44 | // makeTypeID - Return the TypeID for the specified type 'T'.
45 | template <class T>
46 | inline TypeID const& makeTypeIDImp() {
47 | #ifdef _MSC_VER
48 |   static const TypeID id(__FUNCSIG__);
49 | #else
50 |   static const TypeID id(__PRETTY_FUNCTION__);
51 | #endif // _MSC_VER
52 |   return id;
53 | }
54 | 
55 | template <class T>
56 | struct TypeWrapper {};
57 | 
58 | template <class T>
59 | inline  TypeID const& makeTypeID() {
60 |   return makeTypeIDImp<TypeWrapper<T>>();
61 | }
62 | 
63 | template <class ...Args>
64 | struct ArgumentListID {};
65 | 
66 | // makeArgumentID - Create and return a unique identifier for a given set
67 | // of arguments.
68 | template <class ...Args>
69 | inline  TypeID const& makeArgumentID() {
70 |   return makeTypeIDImp<ArgumentListID<Args...>>();
71 | }
72 | 
73 | 
74 | // COMPARE_TYPEID(...) is a utility macro for generating diagnostics when
75 | // two typeid's are expected to be equal
76 | #define COMPARE_TYPEID(LHS, RHS) CompareTypeIDVerbose(#LHS, LHS, #RHS, RHS)
77 | 
78 | inline bool CompareTypeIDVerbose(const char* LHSString, TypeID const* LHS,
79 |                                  const char* RHSString, TypeID const* RHS) {
80 |   if (*LHS == *RHS)
81 |     return true;
82 |   std::printf("TypeID's not equal:\n");
83 |   std::printf("%s: %s\n----------\n%s: %s\n",
84 |               LHSString, LHS->name().c_str(),
85 |               RHSString, RHS->name().c_str());
86 |   return false;
87 | }
88 | 
89 | #endif // SUPPORT_TYPE_ID_H
90 | 


--------------------------------------------------------------------------------
/tests/variant_test_helpers.h:
--------------------------------------------------------------------------------
  1 | // -*- C++ -*-
  2 | //===----------------------------------------------------------------------===//
  3 | //
  4 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  5 | // See https://llvm.org/LICENSE.txt for license information.
  6 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  7 | //
  8 | //===----------------------------------------------------------------------===//
  9 | #ifndef SUPPORT_VARIANT_TEST_HELPERS_H
 10 | #define SUPPORT_VARIANT_TEST_HELPERS_H
 11 | 
 12 | 
 13 | #include <type_traits>
 14 | #include <utility>
 15 | #include <cassert>
 16 | 
 17 | #include <swl/variant.hpp>
 18 | 
 19 | #include "test_macros.h"
 20 | #include "type_id.h"
 21 | 
 22 | #if TEST_STD_VER <= 14
 23 | #error This file requires C++17
 24 | #endif
 25 | 
 26 | // FIXME: Currently the variant<T&> tests are disabled using this macro.
 27 | #define TEST_VARIANT_HAS_NO_REFERENCES
 28 | #ifdef _LIBCPP_ENABLE_NARROWING_CONVERSIONS_IN_VARIANT
 29 | # define TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
 30 | #endif
 31 | 
 32 | #ifdef TEST_VARIANT_ALLOWS_NARROWING_CONVERSIONS
 33 | constexpr bool VariantAllowsNarrowingConversions = true;
 34 | #else
 35 | constexpr bool VariantAllowsNarrowingConversions = false;
 36 | #endif
 37 | 
 38 | #ifndef TEST_HAS_NO_EXCEPTIONS
 39 | struct CopyThrows {
 40 |   CopyThrows() = default;
 41 |   CopyThrows(CopyThrows const&) { throw 42; }
 42 |   CopyThrows& operator=(CopyThrows const&) { throw 42; }
 43 | };
 44 | 
 45 | struct MoveThrows {
 46 |   static int alive;
 47 |   MoveThrows() { ++alive; }
 48 |   MoveThrows(MoveThrows const&) {++alive;}
 49 |   MoveThrows(MoveThrows&&) {  throw 42; }
 50 |   MoveThrows& operator=(MoveThrows const&) { return *this; }
 51 |   MoveThrows& operator=(MoveThrows&&) { throw 42; }
 52 |   ~MoveThrows() { --alive; }
 53 | };
 54 | 
 55 | int MoveThrows::alive = 0;
 56 | 
 57 | struct MakeEmptyT {
 58 |   static int alive;
 59 |   MakeEmptyT() { ++alive; }
 60 |   MakeEmptyT(MakeEmptyT const&) {
 61 |       ++alive;
 62 |       // Don't throw from the copy constructor since variant's assignment
 63 |       // operator performs a copy before committing to the assignment.
 64 |   }
 65 |   MakeEmptyT(MakeEmptyT &&) {
 66 |       throw 42;
 67 |   }
 68 |   MakeEmptyT& operator=(MakeEmptyT const&) {
 69 |       throw 42;
 70 |   }
 71 |   MakeEmptyT& operator=(MakeEmptyT&&) {
 72 |       throw 42;
 73 |   }
 74 |    ~MakeEmptyT() { --alive; }
 75 | };
 76 | static_assert(std::is_swappable_v<MakeEmptyT>, ""); // required for test
 77 | 
 78 | int MakeEmptyT::alive = 0;
 79 | 
 80 | template <class Variant>
 81 | void makeEmpty(Variant& v) {
 82 |     Variant v2(swl::in_place_type<MakeEmptyT>);
 83 |     try {
 84 |         v = std::move(v2);
 85 |         assert(false);
 86 |     } catch (...) {
 87 |         assert(v.valueless_by_exception());
 88 |     }
 89 | }
 90 | #endif // TEST_HAS_NO_EXCEPTIONS
 91 | 
 92 | enum CallType : unsigned {
 93 |   CT_None,
 94 |   CT_NonConst = 1,
 95 |   CT_Const = 2,
 96 |   CT_LValue = 4,
 97 |   CT_RValue = 8
 98 | };
 99 | 
100 | inline constexpr CallType operator|(CallType LHS, CallType RHS) {
101 |   return static_cast<CallType>(static_cast<unsigned>(LHS) |
102 |                                static_cast<unsigned>(RHS));
103 | }
104 | 
105 | struct ForwardingCallObject {
106 | 
107 |   template <class... Args>
108 |   ForwardingCallObject& operator()(Args&&...) & {
109 |     set_call<Args &&...>(CT_NonConst | CT_LValue);
110 |     return *this;
111 |   }
112 | 
113 |   template <class... Args>
114 |   const ForwardingCallObject& operator()(Args&&...) const & {
115 |     set_call<Args &&...>(CT_Const | CT_LValue);
116 |     return *this;
117 |   }
118 | 
119 |   template <class... Args>
120 |   ForwardingCallObject&& operator()(Args&&...) && {
121 |     set_call<Args &&...>(CT_NonConst | CT_RValue);
122 |     return std::move(*this);
123 |   }
124 | 
125 |   template <class... Args>
126 |   const ForwardingCallObject&& operator()(Args&&...) const && {
127 |     set_call<Args &&...>(CT_Const | CT_RValue);
128 |     return std::move(*this);
129 |   }
130 | 
131 |   template <class... Args> static void set_call(CallType type) {
132 |     assert(last_call_type == CT_None);
133 |     assert(last_call_args == nullptr);
134 |     last_call_type = type;
135 |     last_call_args = std::addressof(makeArgumentID<Args...>());
136 |   }
137 | 
138 |   template <class... Args> static bool check_call(CallType type) {
139 |     bool result = last_call_type == type && last_call_args &&
140 |                   *last_call_args == makeArgumentID<Args...>();
141 |     last_call_type = CT_None;
142 |     last_call_args = nullptr;
143 |     return result;
144 |   }
145 | 
146 |   // To check explicit return type for visit<R>
147 |   constexpr operator int() const
148 |   {
149 |     return 0;
150 |   }
151 | 
152 |   static CallType last_call_type;
153 |   static const TypeID *last_call_args;
154 | };
155 | 
156 | CallType ForwardingCallObject::last_call_type = CT_None;
157 | const TypeID *ForwardingCallObject::last_call_args = nullptr;
158 | 
159 | struct ReturnFirst {
160 |   template <class... Args> constexpr int operator()(int f, Args &&...) const {
161 |     return f;
162 |   }
163 | };
164 | 
165 | struct ReturnArity {
166 |   template <class... Args> constexpr int operator()(Args &&...) const {
167 |     return sizeof...(Args);
168 |   }
169 | };
170 | 
171 | #endif // SUPPORT_VARIANT_TEST_HELPERS_H
172 | 


--------------------------------------------------------------------------------