Home | History | Annotate | Download | only in pairs.pair 
      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 
     10 // The test fails due to the missing is_trivially_constructible intrinsic.
     11 // XFAIL: gcc-4.9
     12 
     13 // The test suite needs to define the ABI macros on the command line when
     14 // modules are enabled.
     15 // UNSUPPORTED: -fmodules
     16 
     17 // <utility>
     18 
     19 // template <class T1, class T2> struct pair
     20 
     21 // Test that we properly provide the trivial copy operations by default.
     22 
     23 // FreeBSD provides the old ABI. This test checks the new ABI so we need
     24 // to manually turn it on.
     25 #undef _LIBCPP_ABI_UNSTABLE
     26 #undef _LIBCPP_ABI_VERSION
     27 #define _LIBCPP_ABI_VERSION 1
     28 #define _LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR
     29 
     30 #include <utility>
     31 #include <type_traits>
     32 #include <cstdlib>
     33 #include <cassert>
     34 
     35 #include "test_macros.h"
     36 
     37 #if !defined(_LIBCPP_DEPRECATED_ABI_DISABLE_PAIR_TRIVIAL_COPY_CTOR)
     38 #error trivial ctor ABI macro defined
     39 #endif
     40 
     41 template <class T>
     42 struct HasNonTrivialABI : std::integral_constant<bool,
     43     !std::is_trivially_destructible<T>::value
     44     || (std::is_copy_constructible<T>::value && !std::is_trivially_copy_constructible<T>::value)
     45 #if TEST_STD_VER >= 11
     46    || (std::is_move_constructible<T>::value && !std::is_trivially_move_constructible<T>::value)
     47 #endif
     48 > {};
     49 
     50 #if TEST_STD_VER >= 11
     51 struct NonTrivialDtor {
     52     NonTrivialDtor(NonTrivialDtor const&) = default;
     53     ~NonTrivialDtor();
     54 };
     55 NonTrivialDtor::~NonTrivialDtor() {}
     56 static_assert(HasNonTrivialABI<NonTrivialDtor>::value, "");
     57 
     58 struct NonTrivialCopy {
     59     NonTrivialCopy(NonTrivialCopy const&);
     60 };
     61 NonTrivialCopy::NonTrivialCopy(NonTrivialCopy const&) {}
     62 static_assert(HasNonTrivialABI<NonTrivialCopy>::value, "");
     63 
     64 struct NonTrivialMove {
     65     NonTrivialMove(NonTrivialMove const&) = default;
     66     NonTrivialMove(NonTrivialMove&&);
     67 };
     68 NonTrivialMove::NonTrivialMove(NonTrivialMove&&) {}
     69 static_assert(HasNonTrivialABI<NonTrivialMove>::value, "");
     70 
     71 struct DeletedCopy {
     72     DeletedCopy(DeletedCopy const&) = delete;
     73     DeletedCopy(DeletedCopy&&) = default;
     74 };
     75 static_assert(!HasNonTrivialABI<DeletedCopy>::value, "");
     76 
     77 struct TrivialMove {
     78   TrivialMove(TrivialMove &&) = default;
     79 };
     80 static_assert(!HasNonTrivialABI<TrivialMove>::value, "");
     81 
     82 struct Trivial {
     83     Trivial(Trivial const&) = default;
     84 };
     85 static_assert(!HasNonTrivialABI<Trivial>::value, "");
     86 #endif
     87 
     88 
     89 int main()
     90 {
     91     {
     92         typedef std::pair<int, short> P;
     93         static_assert(std::is_copy_constructible<P>::value, "");
     94         static_assert(HasNonTrivialABI<P>::value, "");
     95     }
     96 #if TEST_STD_VER >= 11
     97     {
     98         typedef std::pair<int, short> P;
     99         static_assert(std::is_move_constructible<P>::value, "");
    100         static_assert(HasNonTrivialABI<P>::value, "");
    101     }
    102     {
    103         using P = std::pair<NonTrivialDtor, int>;
    104         static_assert(!std::is_trivially_destructible<P>::value, "");
    105         static_assert(std::is_copy_constructible<P>::value, "");
    106         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    107         static_assert(std::is_move_constructible<P>::value, "");
    108         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    109         static_assert(HasNonTrivialABI<P>::value, "");
    110     }
    111     {
    112         using P = std::pair<NonTrivialCopy, int>;
    113         static_assert(std::is_copy_constructible<P>::value, "");
    114         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    115         static_assert(std::is_move_constructible<P>::value, "");
    116         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    117         static_assert(HasNonTrivialABI<P>::value, "");
    118     }
    119     {
    120         using P = std::pair<NonTrivialMove, int>;
    121         static_assert(std::is_copy_constructible<P>::value, "");
    122         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    123         static_assert(std::is_move_constructible<P>::value, "");
    124         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    125         static_assert(HasNonTrivialABI<P>::value, "");
    126     }
    127     {
    128         using P = std::pair<DeletedCopy, int>;
    129         static_assert(!std::is_copy_constructible<P>::value, "");
    130         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    131         static_assert(std::is_move_constructible<P>::value, "");
    132         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    133         static_assert(HasNonTrivialABI<P>::value, "");
    134     }
    135     {
    136         using P = std::pair<Trivial, int>;
    137         static_assert(std::is_copy_constructible<P>::value, "");
    138         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    139         static_assert(std::is_move_constructible<P>::value, "");
    140         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    141         static_assert(HasNonTrivialABI<P>::value, "");
    142     }
    143     {
    144         using P = std::pair<TrivialMove, int>;
    145         static_assert(!std::is_copy_constructible<P>::value, "");
    146         static_assert(!std::is_trivially_copy_constructible<P>::value, "");
    147         static_assert(std::is_move_constructible<P>::value, "");
    148         static_assert(!std::is_trivially_move_constructible<P>::value, "");
    149         static_assert(HasNonTrivialABI<P>::value, "");
    150     }
    151 #endif
    152 }
    153