libcxx

libcxx mirror with random patches
git clone https://git.neptards.moe/neptards/libcxx.git
Log | Files | Refs

construct.pass.cpp (3776B)

      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 // <memory>
     11 
     12 // allocator:
     13 // template <class... Args> void construct(pointer p, Args&&... args);
     14 
     15 #include <memory>
     16 #include <cassert>
     17 
     18 #include "test_macros.h"
     19 #include "count_new.hpp"
     20 
     21 int A_constructed = 0;
     22 
     23 struct A
     24 {
     25     int data;
     26     A() {++A_constructed;}
     27 
     28     A(const A&) {++A_constructed;}
     29 
     30     explicit A(int) {++A_constructed;}
     31     A(int, int*) {++A_constructed;}
     32 
     33     ~A() {--A_constructed;}
     34 };
     35 
     36 int move_only_constructed = 0;
     37 
     38 #if TEST_STD_VER >= 11
     39 class move_only
     40 {
     41     move_only(const move_only&) = delete;
     42     move_only& operator=(const move_only&)= delete;
     43 
     44 public:
     45     move_only(move_only&&) {++move_only_constructed;}
     46     move_only& operator=(move_only&&) {return *this;}
     47 
     48     move_only() {++move_only_constructed;}
     49     ~move_only() {--move_only_constructed;}
     50 
     51 public:
     52     int data; // unused other than to make sizeof(move_only) == sizeof(int).
     53               // but public to suppress "-Wunused-private-field"
     54 };
     55 #endif // TEST_STD_VER >= 11
     56 
     57 int main()
     58 {
     59     {
     60     std::allocator<A> a;
     61     assert(globalMemCounter.checkOutstandingNewEq(0));
     62     assert(A_constructed == 0);
     63 
     64     globalMemCounter.last_new_size = 0;
     65     A* ap = a.allocate(3);
     66     DoNotOptimize(ap);
     67     assert(globalMemCounter.checkOutstandingNewEq(1));
     68     assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
     69     assert(A_constructed == 0);
     70 
     71     a.construct(ap);
     72     assert(globalMemCounter.checkOutstandingNewEq(1));
     73     assert(A_constructed == 1);
     74 
     75     a.destroy(ap);
     76     assert(globalMemCounter.checkOutstandingNewEq(1));
     77     assert(A_constructed == 0);
     78 
     79     a.construct(ap, A());
     80     assert(globalMemCounter.checkOutstandingNewEq(1));
     81     assert(A_constructed == 1);
     82 
     83     a.destroy(ap);
     84     assert(globalMemCounter.checkOutstandingNewEq(1));
     85     assert(A_constructed == 0);
     86 
     87     a.construct(ap, 5);
     88     assert(globalMemCounter.checkOutstandingNewEq(1));
     89     assert(A_constructed == 1);
     90 
     91     a.destroy(ap);
     92     assert(globalMemCounter.checkOutstandingNewEq(1));
     93     assert(A_constructed == 0);
     94 
     95     a.construct(ap, 5, (int*)0);
     96     assert(globalMemCounter.checkOutstandingNewEq(1));
     97     assert(A_constructed == 1);
     98 
     99     a.destroy(ap);
    100     assert(globalMemCounter.checkOutstandingNewEq(1));
    101     assert(A_constructed == 0);
    102 
    103     a.deallocate(ap, 3);
    104     DoNotOptimize(ap);
    105     assert(globalMemCounter.checkOutstandingNewEq(0));
    106     assert(A_constructed == 0);
    107     }
    108 #if TEST_STD_VER >= 11
    109     {
    110     std::allocator<move_only> a;
    111     assert(globalMemCounter.checkOutstandingNewEq(0));
    112     assert(move_only_constructed == 0);
    113 
    114     globalMemCounter.last_new_size = 0;
    115     move_only* ap = a.allocate(3);
    116     DoNotOptimize(ap);
    117     assert(globalMemCounter.checkOutstandingNewEq(1));
    118     assert(globalMemCounter.checkLastNewSizeEq(3 * sizeof(int)));
    119     assert(move_only_constructed == 0);
    120 
    121     a.construct(ap);
    122     assert(globalMemCounter.checkOutstandingNewEq(1));
    123     assert(move_only_constructed == 1);
    124 
    125     a.destroy(ap);
    126     assert(globalMemCounter.checkOutstandingNewEq(1));
    127     assert(move_only_constructed == 0);
    128 
    129     a.construct(ap, move_only());
    130     assert(globalMemCounter.checkOutstandingNewEq(1));
    131     assert(move_only_constructed == 1);
    132 
    133     a.destroy(ap);
    134     assert(globalMemCounter.checkOutstandingNewEq(1));
    135     assert(move_only_constructed == 0);
    136 
    137     a.deallocate(ap, 3);
    138     DoNotOptimize(ap);
    139     assert(globalMemCounter.checkOutstandingNewEq(0));
    140     assert(move_only_constructed == 0);
    141     }
    142 #endif
    143 }