Retro68/gcc/libstdc++-v3/testsuite/experimental/optional/requirements.cc
2017-10-07 02:16:47 +02:00

259 lines
9.3 KiB
C++

// { dg-do run { target c++14 } }
// Copyright (C) 2013-2017 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library. This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License along
// with this library; see the file COPYING3. If not see
// <http://www.gnu.org/licenses/>.
#include <experimental/optional>
#include <testsuite_hooks.h>
#include <tuple>
using std::experimental::bad_optional_access;
static_assert( std::is_default_constructible<bad_optional_access>::value, "" );
struct trivially_destructible
{
trivially_destructible() = delete;
trivially_destructible(trivially_destructible const&) = delete;
trivially_destructible& operator=(trivially_destructible const&) = delete;
trivially_destructible(trivially_destructible&&) = delete;
trivially_destructible& operator=(trivially_destructible&&) = delete;
~trivially_destructible() noexcept = default;
};
static_assert( std::is_trivially_destructible<trivially_destructible>(), "" );
struct no_default_constructor
{
no_default_constructor() = delete;
};
struct no_copy_constructor
{
no_copy_constructor() = default;
no_copy_constructor(no_copy_constructor const&) = delete;
no_copy_constructor& operator=(no_copy_constructor const&) = default;
no_copy_constructor(no_copy_constructor&&) = default;
no_copy_constructor& operator=(no_copy_constructor&&) = default;
};
struct no_copy_assignment
{
no_copy_assignment() = default;
no_copy_assignment(no_copy_assignment const&) = default;
no_copy_assignment(no_copy_assignment&&) = default;
no_copy_assignment& operator=(no_copy_assignment&&) = default;
};
struct no_move_constructor
{
no_move_constructor() = default;
no_move_constructor(no_move_constructor const&) = default;
no_move_constructor& operator=(no_move_constructor const&) = default;
no_move_constructor(no_move_constructor&&) = delete;
no_move_constructor& operator=(no_move_constructor&&) = default;
};
struct no_move_assignment
{
no_move_assignment() = default;
no_move_assignment(no_move_assignment const&) = default;
no_move_assignment& operator=(no_move_assignment const&) = default;
no_move_assignment(no_move_assignment&&) = default;
no_move_assignment& operator=(no_move_assignment&&) = delete;
};
struct no_copy : no_copy_constructor, no_copy_assignment { };
struct no_move : no_move_constructor, no_move_assignment { };
// Laxest possible model of a value type for optional
struct only_destructible
{
only_destructible(only_destructible&&) = delete;
};
int main()
{
{
static_assert( std::is_trivially_destructible<std::experimental::optional<trivially_destructible>>(), "" );
}
{
using T = no_default_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy_assignment;
using O = std::experimental::optional<T>;
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_copy;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move_constructor;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
/*
* T should be move constructible due to [12.8/11], which is a new rule in C++1y
* not yet implemented by GCC. Because there is already a special exception in C++11
* for the generation of the special members that GCC implements (at least some of the
* time), this does not affect the std::experimental::optional implementation however. So the assertion
* for T should be changed (or removed altogether) when the time comes, but the rest
* should however remain correct and unchanged.
*/
static_assert( !std::is_move_constructible<T>(), "" );
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move_assignment;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
/*
* Paragraph 23 of same leads to a similar situation but with respect to move
* assignment.
*/
static_assert( !std::is_move_assignable<T>(), "" );
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = no_move;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( std::is_copy_constructible<O>(), "" );
{ O o; auto copy = o; }
static_assert( std::is_copy_assignable<O>(), "" );
{ O o, p; p = o; }
static_assert( std::is_move_constructible<O>(), "" );
{ O o; auto moved_to = std::move(o); }
static_assert( std::is_move_assignable<O>(), "" );
{ O o, p; p = std::move(o); }
}
{
using T = only_destructible;
using O = std::experimental::optional<T>;
static_assert( std::is_same<O::value_type, T>(), "" );
static_assert( std::is_default_constructible<O>(), "" );
{ O o; }
static_assert( !std::is_copy_constructible<O>(), "" );
static_assert( !std::is_copy_assignable<O>(), "" );
static_assert( !std::is_move_constructible<O>(), "" );
static_assert( !std::is_move_assignable<O>(), "" );
}
{
/*
* Should not complain about 'invalid' specializations as long as
* they're not instantiated.
*/
using A = std::experimental::optional<int&>;
using B = std::experimental::optional<int&&>;
using C1 = std::experimental::optional<std::experimental::in_place_t>;
using C2 = std::experimental::optional<std::experimental::in_place_t const>;
using C3 = std::experimental::optional<std::experimental::in_place_t volatile>;
using C4 = std::experimental::optional<std::experimental::in_place_t const volatile>;
using D1 = std::experimental::optional<std::experimental::nullopt_t>;
using D2 = std::experimental::optional<std::experimental::nullopt_t const>;
using D3 = std::experimental::optional<std::experimental::nullopt_t volatile>;
using D4 = std::experimental::optional<std::experimental::nullopt_t const volatile>;
using X = std::tuple<A, B, C1, C2, C3, C4, D1, D2, D3, D4>;
}
{
std::experimental::optional<const int> o { 42 };
static_assert( std::is_same<decltype(o)::value_type, const int>(), "" );
VERIFY( o );
VERIFY( *o == 42 );
}
{
constexpr std::experimental::optional<const int> o { 33 };
static_assert( std::is_same<decltype(o)::value_type, const int>(), "" );
static_assert( o, "" );
static_assert( *o == 33, "" );
}
}