2659663ee3
Some time ago, I introduced shortcut features like dylib-has-no-shared_mutex to encode whether the deployment target supported shared_mutex (say). This made the test suite annotations cleaner. However, the problem with building Lit features on top of other Lit features is that it's easier for them to become stale, especially when they are generated programmatically. Furthermore, it makes the bar for defining configurations from scratch higher, since more features have to be defined. Instead, I think it's better to put the XFAILs in the tests directly, which allows cleaning them up with a simple grep.
300 lines
8.3 KiB
C++
300 lines
8.3 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// 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
|
|
|
|
// Throwing bad_variant_access is supported starting in macosx10.13
|
|
// XFAIL: with_system_cxx_lib=macosx10.12 && !no-exceptions
|
|
// XFAIL: with_system_cxx_lib=macosx10.11 && !no-exceptions
|
|
// XFAIL: with_system_cxx_lib=macosx10.10 && !no-exceptions
|
|
// XFAIL: with_system_cxx_lib=macosx10.9 && !no-exceptions
|
|
|
|
// <variant>
|
|
|
|
// template <size_t I, class... Types>
|
|
// constexpr variant_alternative_t<I, variant<Types...>>&
|
|
// get(variant<Types...>& v);
|
|
// template <size_t I, class... Types>
|
|
// constexpr variant_alternative_t<I, variant<Types...>>&&
|
|
// get(variant<Types...>&& v);
|
|
// template <size_t I, class... Types>
|
|
// constexpr variant_alternative_t<I, variant<Types...>> const& get(const
|
|
// variant<Types...>& v);
|
|
// template <size_t I, class... Types>
|
|
// constexpr variant_alternative_t<I, variant<Types...>> const&& get(const
|
|
// variant<Types...>&& v);
|
|
|
|
#include "test_macros.h"
|
|
#include "test_workarounds.h"
|
|
#include "variant_test_helpers.h"
|
|
#include <cassert>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#include <variant>
|
|
|
|
void test_const_lvalue_get() {
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
constexpr V v(42);
|
|
#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
|
|
ASSERT_NOEXCEPT(std::get<0>(v));
|
|
#else
|
|
ASSERT_NOT_NOEXCEPT(std::get<0>(v));
|
|
#endif
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
|
|
static_assert(std::get<0>(v) == 42, "");
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
const V v(42);
|
|
ASSERT_NOT_NOEXCEPT(std::get<0>(v));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
|
|
assert(std::get<0>(v) == 42);
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
constexpr V v(42l);
|
|
#ifdef TEST_WORKAROUND_CONSTEXPR_IMPLIES_NOEXCEPT
|
|
ASSERT_NOEXCEPT(std::get<1>(v));
|
|
#else
|
|
ASSERT_NOT_NOEXCEPT(std::get<1>(v));
|
|
#endif
|
|
ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
|
|
static_assert(std::get<1>(v) == 42, "");
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
const V v(42l);
|
|
ASSERT_NOT_NOEXCEPT(std::get<1>(v));
|
|
ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
|
|
assert(std::get<1>(v) == 42);
|
|
}
|
|
// FIXME: Remove these once reference support is reinstated
|
|
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
|
|
{
|
|
using V = std::variant<int &>;
|
|
int x = 42;
|
|
const V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<int &&>;
|
|
int x = 42;
|
|
const V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &&>;
|
|
int x = 42;
|
|
const V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void test_lvalue_get() {
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
V v(42);
|
|
ASSERT_NOT_NOEXCEPT(std::get<0>(v));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
|
|
assert(std::get<0>(v) == 42);
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
V v(42l);
|
|
ASSERT_SAME_TYPE(decltype(std::get<1>(v)), const long &);
|
|
assert(std::get<1>(v) == 42);
|
|
}
|
|
// FIXME: Remove these once reference support is reinstated
|
|
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
|
|
{
|
|
using V = std::variant<int &>;
|
|
int x = 42;
|
|
V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &>;
|
|
int x = 42;
|
|
V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<int &&>;
|
|
int x = 42;
|
|
V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &&>;
|
|
int x = 42;
|
|
V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(v)), const int &);
|
|
assert(&std::get<0>(v) == &x);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void test_rvalue_get() {
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
V v(42);
|
|
ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &&);
|
|
assert(std::get<0>(std::move(v)) == 42);
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
V v(42l);
|
|
ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
|
|
assert(std::get<1>(std::move(v)) == 42);
|
|
}
|
|
// FIXME: Remove these once reference support is reinstated
|
|
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
|
|
{
|
|
using V = std::variant<int &>;
|
|
int x = 42;
|
|
V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &);
|
|
assert(&std::get<0>(std::move(v)) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &>;
|
|
int x = 42;
|
|
V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &);
|
|
assert(&std::get<0>(std::move(v)) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<int &&>;
|
|
int x = 42;
|
|
V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &&);
|
|
int &&xref = std::get<0>(std::move(v));
|
|
assert(&xref == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &&>;
|
|
int x = 42;
|
|
V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &&);
|
|
const int &&xref = std::get<0>(std::move(v));
|
|
assert(&xref == &x);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void test_const_rvalue_get() {
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
const V v(42);
|
|
ASSERT_NOT_NOEXCEPT(std::get<0>(std::move(v)));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &&);
|
|
assert(std::get<0>(std::move(v)) == 42);
|
|
}
|
|
{
|
|
using V = std::variant<int, const long>;
|
|
const V v(42l);
|
|
ASSERT_SAME_TYPE(decltype(std::get<1>(std::move(v))), const long &&);
|
|
assert(std::get<1>(std::move(v)) == 42);
|
|
}
|
|
// FIXME: Remove these once reference support is reinstated
|
|
#if !defined(TEST_VARIANT_HAS_NO_REFERENCES)
|
|
{
|
|
using V = std::variant<int &>;
|
|
int x = 42;
|
|
const V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &);
|
|
assert(&std::get<0>(std::move(v)) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &>;
|
|
int x = 42;
|
|
const V v(x);
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &);
|
|
assert(&std::get<0>(std::move(v)) == &x);
|
|
}
|
|
{
|
|
using V = std::variant<int &&>;
|
|
int x = 42;
|
|
const V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), int &&);
|
|
int &&xref = std::get<0>(std::move(v));
|
|
assert(&xref == &x);
|
|
}
|
|
{
|
|
using V = std::variant<const int &&>;
|
|
int x = 42;
|
|
const V v(std::move(x));
|
|
ASSERT_SAME_TYPE(decltype(std::get<0>(std::move(v))), const int &&);
|
|
const int &&xref = std::get<0>(std::move(v));
|
|
assert(&xref == &x);
|
|
}
|
|
#endif
|
|
}
|
|
|
|
template <std::size_t I> using Idx = std::integral_constant<size_t, I>;
|
|
|
|
void test_throws_for_all_value_categories() {
|
|
#ifndef TEST_HAS_NO_EXCEPTIONS
|
|
using V = std::variant<int, long>;
|
|
V v0(42);
|
|
const V &cv0 = v0;
|
|
assert(v0.index() == 0);
|
|
V v1(42l);
|
|
const V &cv1 = v1;
|
|
assert(v1.index() == 1);
|
|
std::integral_constant<size_t, 0> zero;
|
|
std::integral_constant<size_t, 1> one;
|
|
auto test = [](auto idx, auto &&v) {
|
|
using Idx = decltype(idx);
|
|
try {
|
|
TEST_IGNORE_NODISCARD std::get<Idx::value>(std::forward<decltype(v)>(v));
|
|
} catch (const std::bad_variant_access &) {
|
|
return true;
|
|
} catch (...) { /* ... */
|
|
}
|
|
return false;
|
|
};
|
|
{ // lvalue test cases
|
|
assert(test(one, v0));
|
|
assert(test(zero, v1));
|
|
}
|
|
{ // const lvalue test cases
|
|
assert(test(one, cv0));
|
|
assert(test(zero, cv1));
|
|
}
|
|
{ // rvalue test cases
|
|
assert(test(one, std::move(v0)));
|
|
assert(test(zero, std::move(v1)));
|
|
}
|
|
{ // const rvalue test cases
|
|
assert(test(one, std::move(cv0)));
|
|
assert(test(zero, std::move(cv1)));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
int main(int, char**) {
|
|
test_const_lvalue_get();
|
|
test_lvalue_get();
|
|
test_rvalue_get();
|
|
test_const_rvalue_get();
|
|
test_throws_for_all_value_categories();
|
|
|
|
return 0;
|
|
}
|