Home | History | Annotate | Download | only in new.delete.array
      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 // test nothrow sized operator delete[] by replacing
     11 // nothrow unsized operator delete[].
     12 
     13 // UNSUPPORTED: asan, msan
     14 
     15 #include <new>
     16 #include <cstddef>
     17 #include <cstdlib>
     18 #include <cassert>
     19 #include <limits>
     20 
     21 int delete_called = 0;
     22 int delete_nothrow_called = 0;
     23 
     24 void operator delete[](void* p) throw()
     25 {
     26     ++delete_called;
     27     std::free(p);
     28 }
     29 
     30 void operator delete[](void* p, const std::nothrow_t&) throw()
     31 {
     32     ++delete_nothrow_called;
     33     std::free(p);
     34 }
     35 
     36 int new_handler_called = 0;
     37 
     38 void new_handler()
     39 {
     40     ++new_handler_called;
     41     std::set_new_handler(0);
     42 }
     43 
     44 bool A_constructed = false;
     45 
     46 struct A
     47 {
     48     A() {A_constructed = true;}
     49     ~A() {A_constructed = false;}
     50 };
     51 
     52 struct BadA : public A {
     53   BadA() { throw std::bad_alloc(); }
     54 };
     55 
     56 int main()
     57 {
     58     std::set_new_handler(new_handler);
     59     try
     60     {
     61         void*volatile vp = operator new [] (std::numeric_limits<std::size_t>::max(), std::nothrow);
     62         assert(new_handler_called == 1);
     63         assert(vp == 0);
     64     }
     65     catch (...)
     66     {
     67         assert(false);
     68     }
     69     try
     70     {
     71         A* ap = new(std::nothrow) BadA [3];
     72         assert(false);
     73     }
     74     catch (...)
     75     {
     76         assert(!A_constructed);
     77         assert(!delete_called);
     78         assert(delete_nothrow_called == 1);
     79     }
     80 }
     81