src/third_party/libc++/trunk/test/utilities/memory/util.smartptr/util.smartptr.weak/util.smartptr.weak.const/weak_ptr_Y.pass.cpp

   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 // weak_ptr
  13
  14 // template<class Y> weak_ptr(const weak_ptr<Y>& r);
  15
  16 #include <memory>
  17 #include <type_traits>
  18 #include <cassert>
  19
  20 struct B
  21 {
  22     static int count;
  23
  24     B() {++count;}
  25     B(const B&) {++count;}
  26     virtual ~B() {--count;}
  27 };
  28
  29 int B::count = 0;
  30
  31 struct A
  32     : public B
  33 {
  34     static int count;
  35
  36     A() {++count;}
  37     A(const A&) {++count;}
  38     ~A() {--count;}
  39 };
  40
  41 int A::count = 0;
  42
  43 struct C
  44 {
  45     static int count;
  46
  47     C() {++count;}
  48     C(const C&) {++count;}
  49     virtual ~C() {--count;}
  50 };
  51
  52 int C::count = 0;
  53
  54 int main()
  55 {
  56     static_assert(( std::is_convertible<std::weak_ptr<A>, std::weak_ptr<B> >::value), "");
  57     static_assert((!std::is_convertible<std::weak_ptr<B>, std::weak_ptr<A> >::value), "");
  58     static_assert((!std::is_convertible<std::weak_ptr<A>, std::weak_ptr<C> >::value), "");
  59     {
  60         const std::weak_ptr<A> pA(std::shared_ptr<A>(new A));
  61         assert(pA.use_count() == 0);
  62         assert(B::count == 0);
  63         assert(A::count == 0);
  64         {
  65             std::weak_ptr<B> pB(pA);
  66             assert(B::count == 0);
  67             assert(A::count == 0);
  68             assert(pB.use_count() == 0);
  69             assert(pA.use_count() == 0);
  70         }
  71         assert(pA.use_count() == 0);
  72         assert(B::count == 0);
  73         assert(A::count == 0);
  74     }
  75     assert(B::count == 0);
  76     assert(A::count == 0);
  77     {
  78         std::weak_ptr<A> pA;
  79         assert(pA.use_count() == 0);
  80         assert(B::count == 0);
  81         assert(A::count == 0);
  82         {
  83             std::weak_ptr<B> pB(pA);
  84             assert(B::count == 0);
  85             assert(A::count == 0);
  86             assert(pB.use_count() == 0);
  87             assert(pA.use_count() == 0);
  88         }
  89         assert(pA.use_count() == 0);
  90         assert(B::count == 0);
  91         assert(A::count == 0);
  92     }
  93     assert(B::count == 0);
  94     assert(A::count == 0);
  95 }