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