view libstdc++-v3/testsuite/ext/malloc_allocator/89510.cc @ 19:2b5abeee2509 default tip

update gcc11
author anatofuz
date Mon, 25 May 2020 07:50:57 +0900
parents
children
line wrap: on
line source

// Copyright (C) 2020 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/>.

// { dg-do compile { target c++11 } }

#include <ext/malloc_allocator.h>
#include <memory>
#include <type_traits>

using __gnu_cxx::malloc_allocator;
using AT = std::allocator_traits<malloc_allocator<int>>;

template<typename...> using void_t = void;

template<typename T, typename U, typename = void>
struct has_construct
: std::false_type
{ };

template<typename T, typename U>
struct has_construct<T, U,
    void_t<decltype(std::declval<T&>().construct(std::declval<U*>()))>>
: std::true_type
{ };

template<typename T, typename U, typename = void>
struct has_destroy
: std::false_type
{ };

template<typename T, typename U>
struct has_destroy<T, U,
    void_t<decltype(std::declval<T&>().destroy(std::declval<U*>()))>>
: std::true_type
{ };

template<typename T, typename U, typename = void>
struct has_traits_construct
: std::false_type
{ };

template<typename T, typename U>
struct has_traits_construct<T, U,
    void_t<decltype(AT::construct(std::declval<T&>(), std::declval<U*>()))>>
: std::true_type
{ };

template<typename T, typename U, typename = void>
struct has_traits_destroy
: std::false_type
{ };

template<typename T, typename U>
struct has_traits_destroy<T, U,
    void_t<decltype(AT::destroy(std::declval<T&>(), std::declval<U*>()))>>
: std::true_type
{ };

struct NoDefault { NoDefault(int); };
struct NoDest { private: ~NoDest(); };

// Whether true or false, these should not give errors:
constexpr bool c = has_construct<malloc_allocator<NoDefault>, NoDefault>::value;
constexpr bool c2 = has_traits_construct<malloc_allocator<int>, NoDefault>::value;
constexpr bool d = has_destroy<malloc_allocator<NoDest>, NoDest>::value;
constexpr bool b2 = has_traits_destroy<malloc_allocator<int>, NoDest>::value;

malloc_allocator<int> a;

long* lp;
#if __cplusplus <= 201703L
static_assert( noexcept(a.construct(lp)), "" );
static_assert( noexcept(a.construct(lp, 1L)), "" );
static_assert( noexcept(a.construct(lp, 2)), "" );
static_assert( noexcept(a.construct(lp, 2U)), "" );
static_assert( noexcept(a.destroy(lp)), "" );
#endif
static_assert( noexcept(AT::construct(a, lp)), "" );
static_assert( noexcept(AT::construct(a, lp, 1L)), "" );
static_assert( noexcept(AT::construct(a, lp, 2)), "" );
static_assert( noexcept(AT::construct(a, lp, 2U)), "" );
static_assert( noexcept(AT::destroy(a, lp)), "" );

struct X
{
  X() noexcept;
  X(int) noexcept;
  ~X() noexcept;
};

X* xp;
#if __cplusplus <= 201703L
static_assert( noexcept(a.construct(xp)), "" );
static_assert( noexcept(a.construct(xp, 1)), "" );
static_assert( noexcept(a.destroy(xp)), "" );
#endif
static_assert( noexcept(AT::construct(a, xp)), "" );
static_assert( noexcept(AT::construct(a, xp, 1)), "" );
static_assert( noexcept(AT::destroy(a, xp)), "" );

struct Y
{
  Y() noexcept;
  Y(int) noexcept(false);
  ~Y() noexcept;
};

Y* yp;
#if __cplusplus <= 201703L
static_assert( noexcept(a.construct(yp)), "" );
static_assert( ! noexcept(a.construct(yp, 1)), "" );
static_assert( noexcept(a.destroy(yp)), "" );
#endif
static_assert( noexcept(AT::construct(a, yp)), "" );
static_assert( ! noexcept(AT::construct(a, yp, 1)), "" );
static_assert( noexcept(AT::destroy(a, yp)), "" );

struct Z
{
  Z() noexcept;
  Z(int) noexcept;
  ~Z() noexcept(false);
};

Z* zp;
// These construct calls should be noexcept, but they are false because
// they use is_nothrow_constructible which depends on is_nothrow_destructible.
#if __cplusplus <= 201703L
static_assert( ! noexcept(a.construct(zp)), "wrong" );
static_assert( ! noexcept(a.construct(zp, 1)), "wrong" );
static_assert( ! noexcept(a.destroy(zp)), "" );
#endif
static_assert( ! noexcept(AT::construct(a, zp)), "" );
static_assert( ! noexcept(AT::construct(a, zp, 1)), "" );
static_assert( ! noexcept(AT::destroy(a, zp)), "" );