text: //===----------------------------------------------------------------------===//
  //
  //                     The LLVM Compiler Infrastructure
  //
  // This file is dual licensed under the MIT and the University of Illinois Open
  // Source Licenses. See LICENSE.TXT for details.
  //
  //===----------------------------------------------------------------------===//
  
  // <memory>
  
  // unique_ptr
  
  // Test unique_ptr converting move ctor
  
  // test converting move ctor.  Should only require a MoveConstructible deleter, or if
  //    deleter is a reference, not even that.
  // Explicit version
  
  #include <memory>
  #include <cassert>
  
  struct A
  {
      static int count;
      A() {++count;}
      A(const A&) {++count;}
      virtual ~A() {--count;}
  };
  
  int A::count = 0;
  
  struct B
      : public A
  {
      static int count;
      B() {++count;}
      B(const B&) {++count;}
      virtual ~B() {--count;}
  };
  
  int B::count = 0;
  
  template <class T>
  class CDeleter
  {
      int state_;
  
      CDeleter(CDeleter&);
      CDeleter& operator=(CDeleter&);
  public:
  
      CDeleter() : state_(5) {}
  
      int state() const {return state_;}
      void set_state(int s) {state_ = s;}
  
      void operator()(T* p) {delete p;}
  };
  
  int main()
  {
      {
      CDeleter<A> d;
      std::unique_ptr<B[], CDeleter<A>&> s(new B, d);
      A* p = s.get();
      std::unique_ptr<A[], CDeleter<A>&> s2(std::move(s));
      assert(s2.get() == p);
      assert(s.get() == 0);
      assert(A::count == 1);
      assert(B::count == 1);
      d.set_state(6);
      assert(s2.get_deleter().state() == d.state());
      assert(s.get_deleter().state() ==  d.state());
      }
      assert(A::count == 0);
      assert(B::count == 0);
  }
  