Home | History | Annotate | Download | only in meta.trans.other 
      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 // type_traits
     11 
     12 // aligned_storage
     13 
     14 #include <type_traits>
     15 #include <cstddef>       // for std::max_align_t
     16 #include "test_macros.h"
     17 
     18 int main()
     19 {
     20     {
     21     typedef std::aligned_storage<10, 1 >::type T1;
     22 #if TEST_STD_VER > 11
     23     static_assert(std::is_same<std::aligned_storage_t<10, 1>, T1>::value, "" );
     24 #endif
     25     static_assert(std::alignment_of<T1>::value == 1, "");
     26     static_assert(sizeof(T1) == 10, "");
     27     }
     28     {
     29     typedef std::aligned_storage<10, 2 >::type T1;
     30 #if TEST_STD_VER > 11
     31     static_assert(std::is_same<std::aligned_storage_t<10, 2>, T1>::value, "" );
     32 #endif
     33     static_assert(std::alignment_of<T1>::value == 2, "");
     34     static_assert(sizeof(T1) == 10, "");
     35     }
     36     {
     37     typedef std::aligned_storage<10, 4 >::type T1;
     38 #if TEST_STD_VER > 11
     39     static_assert(std::is_same<std::aligned_storage_t<10, 4>, T1>::value, "" );
     40 #endif
     41     static_assert(std::alignment_of<T1>::value == 4, "");
     42     static_assert(sizeof(T1) == 12, "");
     43     }
     44     {
     45     typedef std::aligned_storage<10, 8 >::type T1;
     46 #if TEST_STD_VER > 11
     47     static_assert(std::is_same<std::aligned_storage_t<10, 8>, T1>::value, "" );
     48 #endif
     49     static_assert(std::alignment_of<T1>::value == 8, "");
     50     static_assert(sizeof(T1) == 16, "");
     51     }
     52     {
     53     typedef std::aligned_storage<10, 16 >::type T1;
     54 #if TEST_STD_VER > 11
     55     static_assert(std::is_same<std::aligned_storage_t<10, 16>, T1>::value, "" );
     56 #endif
     57     static_assert(std::alignment_of<T1>::value == 16, "");
     58     static_assert(sizeof(T1) == 16, "");
     59     }
     60     {
     61     typedef std::aligned_storage<10, 32 >::type T1;
     62 #if TEST_STD_VER > 11
     63     static_assert(std::is_same<std::aligned_storage_t<10, 32>, T1>::value, "" );
     64 #endif
     65     static_assert(std::alignment_of<T1>::value == 32, "");
     66     static_assert(sizeof(T1) == 32, "");
     67     }
     68     {
     69     typedef std::aligned_storage<20, 32 >::type T1;
     70 #if TEST_STD_VER > 11
     71     static_assert(std::is_same<std::aligned_storage_t<20, 32>, T1>::value, "" );
     72 #endif
     73     static_assert(std::alignment_of<T1>::value == 32, "");
     74     static_assert(sizeof(T1) == 32, "");
     75     }
     76     {
     77     typedef std::aligned_storage<40, 32 >::type T1;
     78 #if TEST_STD_VER > 11
     79     static_assert(std::is_same<std::aligned_storage_t<40, 32>, T1>::value, "" );
     80 #endif
     81     static_assert(std::alignment_of<T1>::value == 32, "");
     82     static_assert(sizeof(T1) == 64, "");
     83     }
     84     {
     85     typedef std::aligned_storage<12, 16 >::type T1;
     86 #if TEST_STD_VER > 11
     87     static_assert(std::is_same<std::aligned_storage_t<12, 16>, T1>::value, "" );
     88 #endif
     89     static_assert(std::alignment_of<T1>::value == 16, "");
     90     static_assert(sizeof(T1) == 16, "");
     91     }
     92     {
     93     typedef std::aligned_storage<1>::type T1;
     94 #if TEST_STD_VER > 11
     95     static_assert(std::is_same<std::aligned_storage_t<1>, T1>::value, "" );
     96 #endif
     97     static_assert(std::alignment_of<T1>::value == 1, "");
     98     static_assert(sizeof(T1) == 1, "");
     99     }
    100     {
    101     typedef std::aligned_storage<2>::type T1;
    102 #if TEST_STD_VER > 11
    103     static_assert(std::is_same<std::aligned_storage_t<2>, T1>::value, "" );
    104 #endif
    105     static_assert(std::alignment_of<T1>::value == 2, "");
    106     static_assert(sizeof(T1) == 2, "");
    107     }
    108     {
    109     typedef std::aligned_storage<3>::type T1;
    110 #if TEST_STD_VER > 11
    111     static_assert(std::is_same<std::aligned_storage_t<3>, T1>::value, "" );
    112 #endif
    113     static_assert(std::alignment_of<T1>::value == 2, "");
    114     static_assert(sizeof(T1) == 4, "");
    115     }
    116     {
    117     typedef std::aligned_storage<4>::type T1;
    118 #if TEST_STD_VER > 11
    119     static_assert(std::is_same<std::aligned_storage_t<4>, T1>::value, "" );
    120 #endif
    121     static_assert(std::alignment_of<T1>::value == 4, "");
    122     static_assert(sizeof(T1) == 4, "");
    123     }
    124     {
    125     typedef std::aligned_storage<5>::type T1;
    126 #if TEST_STD_VER > 11
    127     static_assert(std::is_same<std::aligned_storage_t<5>, T1>::value, "" );
    128 #endif
    129     static_assert(std::alignment_of<T1>::value == 4, "");
    130     static_assert(sizeof(T1) == 8, "");
    131     }
    132     {
    133     typedef std::aligned_storage<7>::type T1;
    134 #if TEST_STD_VER > 11
    135     static_assert(std::is_same<std::aligned_storage_t<7>, T1>::value, "" );
    136 #endif
    137     static_assert(std::alignment_of<T1>::value == 4, "");
    138     static_assert(sizeof(T1) == 8, "");
    139     }
    140     {
    141     typedef std::aligned_storage<8>::type T1;
    142 #if TEST_STD_VER > 11
    143     static_assert(std::is_same<std::aligned_storage_t<8>, T1>::value, "" );
    144 #endif
    145     static_assert(std::alignment_of<T1>::value == 8, "");
    146     static_assert(sizeof(T1) == 8, "");
    147     }
    148     {
    149     typedef std::aligned_storage<9>::type T1;
    150 #if TEST_STD_VER > 11
    151     static_assert(std::is_same<std::aligned_storage_t<9>, T1>::value, "" );
    152 #endif
    153     static_assert(std::alignment_of<T1>::value == 8, "");
    154     static_assert(sizeof(T1) == 16, "");
    155     }
    156     {
    157     typedef std::aligned_storage<15>::type T1;
    158 #if TEST_STD_VER > 11
    159     static_assert(std::is_same<std::aligned_storage_t<15>, T1>::value, "" );
    160 #endif
    161     static_assert(std::alignment_of<T1>::value == 8, "");
    162     static_assert(sizeof(T1) == 16, "");
    163     }
    164     // Use alignof(std::max_align_t) below to find the max alignment instead of
    165     // hardcoding it, because it's different on different platforms.
    166     // (For example 8 on arm and 16 on x86.)
    167 #if TEST_STD_VER < 11
    168 #define alignof __alignof__
    169 #endif
    170     {
    171     typedef std::aligned_storage<16>::type T1;
    172 #if TEST_STD_VER > 11
    173     static_assert(std::is_same<std::aligned_storage_t<16>, T1>::value, "" );
    174 #endif
    175     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
    176                   "");
    177     static_assert(sizeof(T1) == 16, "");
    178     }
    179     {
    180     typedef std::aligned_storage<17>::type T1;
    181 #if TEST_STD_VER > 11
    182     static_assert(std::is_same<std::aligned_storage_t<17>, T1>::value, "" );
    183 #endif
    184     static_assert(std::alignment_of<T1>::value == alignof(std::max_align_t),
    185                   "");
    186     static_assert(sizeof(T1) == 16 + alignof(std::max_align_t), "");
    187     }
    188     {
    189     typedef std::aligned_storage<10>::type T1;
    190 #if TEST_STD_VER > 11
    191     static_assert(std::is_same<std::aligned_storage_t<10>, T1>::value, "" );
    192 #endif
    193     static_assert(std::alignment_of<T1>::value == 8, "");
    194     static_assert(sizeof(T1) == 16, "");
    195     }
    196 }
    197