Rewrite and cleanup unique_ptr tests.
This patch almost entirely rewrites the unique_ptr tests. There are a couple of reasons for this: A) Most of the *.fail.cpp tests were either incorrect or could be better written as a *.pass.cpp test that uses <type_traits> to check if certain operations are valid (Ex. Using static_assert(!std::is_copy_constructible_v<T>) instead of writing a failure test). B) [unique.ptr.runtime] has very poor test coverage. Many of the constructors and assignment operators have to tests at all. The special members that have tests have very few test cases and are typically way out of date. C) The tests for [unique.ptr.single] and [unique.ptr.runtime] are largely duplicates of each other. This means common requirements have two different sets of tests in two different test files. This makes the tests harder to maintain than if there was a single copy. To address (A) this patch changes almost all of the *.fail.cpp tests into .pass.cpp tests using type traits; Allowing the *.fail.cpp tests to be removed. The address (B) and (C) the tests for [unique.ptr.single] and [unique.ptr.runtime] have been combined into a single directory, allowing both specializations to share common tests. Tests specific to the single/runtime specializations are given the suffix "*.single.pass.cpp" or "*.runtime.pass.cpp". Finally the unique.ptr test have been moved into the correct directory according to the standard. Specifically they have been removed from "utilities/memory" into "utilities/smartptr". PS. This patch also adds newly written tests for upcoming unique_ptr changes/fixes. However since these tests don't currently pass they are guarded by the macro TEST_WORKAROUND_UPCOMING_UNIQUE_PTR_CHANGES. This allows other STL's to validate the tests before libc++ implements the changes. The relevant libc++ changes should land in the next week. git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@300388 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
@@ -1,12 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
int main()
|
||||
{
|
||||
}
|
||||
@@ -1,44 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03, c++11
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
// The only way to create an unique_ptr<T[]> is to default construct them.
|
||||
|
||||
class foo {
|
||||
public:
|
||||
foo () : val_(3) {}
|
||||
int get () const { return val_; }
|
||||
private:
|
||||
int val_;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
auto p1 = std::make_unique<int[]>(5);
|
||||
for ( int i = 0; i < 5; ++i )
|
||||
assert ( p1[i] == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
auto p2 = std::make_unique<std::string[]>(5);
|
||||
for ( int i = 0; i < 5; ++i )
|
||||
assert ( p2[i].size () == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
auto p3 = std::make_unique<foo[]>(7);
|
||||
for ( int i = 0; i < 7; ++i )
|
||||
assert ( p3[i].get () == 3 );
|
||||
}
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
auto up1 = std::make_unique<std::string[]>("error"); // doesn't compile - no bound
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
auto up2 = std::make_unique<int[]>(10, 20, 30, 40);
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
auto up3 = std::make_unique<int[5]>(); // this is deleted
|
||||
}
|
||||
@@ -1,17 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
auto up4 = std::make_unique<int[5]>(11, 22, 33, 44, 55); // deleted
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03, c++11
|
||||
#include <memory>
|
||||
#include <string>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<int> p1 = std::make_unique<int>(1);
|
||||
assert ( *p1 == 1 );
|
||||
p1 = std::make_unique<int> ();
|
||||
assert ( *p1 == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
std::unique_ptr<std::string> p2 = std::make_unique<std::string> ( "Meow!" );
|
||||
assert ( *p2 == "Meow!" );
|
||||
p2 = std::make_unique<std::string> ();
|
||||
assert ( *p2 == "" );
|
||||
p2 = std::make_unique<std::string> ( 6, 'z' );
|
||||
assert ( *p2 == "zzzzzz" );
|
||||
}
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
int main()
|
||||
{
|
||||
}
|
||||
@@ -1,48 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
#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;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<B> d2;
|
||||
std::default_delete<A> d1 = d2;
|
||||
A* p = new B;
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
d1(p);
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<A> d;
|
||||
A* p = new A;
|
||||
assert(A::count == 1);
|
||||
d(p);
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
// Test that default_delete's operator() requires a complete type
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<A> d;
|
||||
A* p = 0;
|
||||
d(p);
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
// Test that default_delete's operator() requires a complete type
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<const void> d;
|
||||
const void* p = 0;
|
||||
d(p);
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
// Test that default_delete<T[]> does not have a working converting constructor
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
};
|
||||
|
||||
struct B
|
||||
: public A
|
||||
{
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<B[]> d2;
|
||||
std::default_delete<A[]> d1 = d2;
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete[]
|
||||
|
||||
// template <class U>
|
||||
// default_delete(const default_delete<U[]>&);
|
||||
//
|
||||
// This constructor shall not participate in overload resolution unless
|
||||
// U(*)[] is convertible to T(*)[].
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<int[]> d1;
|
||||
std::default_delete<const int[]> d2 = d1;
|
||||
((void)d2);
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
// Test that default_delete<T[]> has a working default constructor
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<A[]> d;
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
d(p);
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,26 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
// default_delete
|
||||
|
||||
// Test that default_delete<T[]>'s operator() requires a complete type
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::default_delete<A[]> d;
|
||||
A* p = 0;
|
||||
d(p);
|
||||
}
|
||||
@@ -1,12 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
int main()
|
||||
{
|
||||
}
|
||||
@@ -1,28 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int> s, s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
|
||||
#else
|
||||
s2 = s; // expected-error {{'operator=' is a private member of 'std::__1::unique_ptr}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,79 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
// test move assignment. Should only require a MoveConstructible deleter, or if
|
||||
// deleter is a reference, not even that.
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> s1(new A[3]);
|
||||
A* p = s1.get();
|
||||
assert(A::count == 3);
|
||||
std::unique_ptr<A[]> s2(new A[2]);
|
||||
assert(A::count == 5);
|
||||
s2 = std::move(s1);
|
||||
assert(A::count == 3);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
std::unique_ptr<A[], Deleter<A[]> > s1(new A[4], Deleter<A[]>(5));
|
||||
A* p = s1.get();
|
||||
assert(A::count == 4);
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(new A[5]);
|
||||
assert(A::count == 9);
|
||||
s2 = std::move(s1);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
assert(A::count == 4);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s1.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
CDeleter<A[]> d1(5);
|
||||
std::unique_ptr<A[], CDeleter<A[]>&> s1(new A[6], d1);
|
||||
A* p = s1.get();
|
||||
assert(A::count == 6);
|
||||
CDeleter<A[]> d2(6);
|
||||
std::unique_ptr<A[], CDeleter<A[]>&> s2(new A[3], d2);
|
||||
assert(A::count == 9);
|
||||
s2 = std::move(s1);
|
||||
assert(A::count == 6);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
assert(d1.state() == 5);
|
||||
assert(d2.state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
// Can't copy from const lvalue
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<A[]> s(new A[3]);
|
||||
std::unique_ptr<A[]> s2;
|
||||
s2 = s;
|
||||
}
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
// Can't copy from lvalue
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A, Deleter> s(new A);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A, Deleter> s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
// test move ctor. Can't copy from const lvalue
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<A, Deleter> s(new A);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A, Deleter> s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
// Can't assign from lvalue
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
boost::unique_ptr<B[], Deleter<B> > s(new B);
|
||||
A* p = s.get();
|
||||
boost::unique_ptr<A[], Deleter<A> > s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
Deleter<B> db(5);
|
||||
boost::unique_ptr<B[], Deleter<B>&> s(new B, db);
|
||||
A* p = s.get();
|
||||
Deleter<A> da(6);
|
||||
boost::unique_ptr<A[], Deleter<A>&> s2(new A, da);
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
// Can't assign from const lvalue
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const boost::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
boost::unique_ptr<A[]> s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const boost::unique_ptr<B[], Deleter<B> > s(new B);
|
||||
A* p = s.get();
|
||||
boost::unique_ptr<A[], Deleter<A> > s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
Deleter<B> db(5);
|
||||
const boost::unique_ptr<B[], Deleter<B>&> s(new B, db);
|
||||
A* p = s.get();
|
||||
Deleter<A> da(6);
|
||||
boost::unique_ptr<A[], Deleter<A>&> s2(new A, da);
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
boost::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
boost::unique_ptr<A[]> s2(new A);
|
||||
assert(A::count == 2);
|
||||
s2 = boost::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,60 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
boost::unique_ptr<B[], Deleter<B> > s(new B);
|
||||
A* p = s.get();
|
||||
boost::unique_ptr<A[], Deleter<A> > s2(new A);
|
||||
assert(A::count == 2);
|
||||
s2 = (boost::move(s));
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// test converting move assignment with reference deleters
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
Deleter<B> db(5);
|
||||
boost::unique_ptr<B[], Deleter<B>&> s(new B, db);
|
||||
A* p = s.get();
|
||||
Deleter<A> da(6);
|
||||
boost::unique_ptr<A[], Deleter<A>&> s2(new A, da);
|
||||
s2 = boost::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
// test assignment from null
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A> s2(new A);
|
||||
assert(A::count == 1);
|
||||
s2 = 0;
|
||||
assert(A::count == 0);
|
||||
assert(s2.get() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// The deleter is not called if get() == 0
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(0) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(void*) {++state_;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
Deleter d;
|
||||
assert(d.state() == 0);
|
||||
{
|
||||
std::unique_ptr<int[], Deleter&> p(nullptr, d);
|
||||
assert(p.get() == 0);
|
||||
assert(&p.get_deleter() == &d);
|
||||
}
|
||||
#if defined(_LIBCPP_VERSION)
|
||||
{
|
||||
// The standard only requires the constructor accept nullptr, but libc++
|
||||
// also supports the literal 0.
|
||||
std::unique_ptr<int[], Deleter&> p(0, d);
|
||||
assert(p.get() == 0);
|
||||
assert(&p.get_deleter() == &d);
|
||||
}
|
||||
#endif
|
||||
assert(d.state() == 0);
|
||||
}
|
||||
@@ -1,41 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
// test assignment from null
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> s2(new A[3]);
|
||||
assert(A::count == 3);
|
||||
s2 = nullptr;
|
||||
assert(A::count == 0);
|
||||
assert(s2.get() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,34 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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<T[]>::pointer type
|
||||
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
|
||||
struct Deleter
|
||||
{
|
||||
struct pointer {};
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
typedef std::unique_ptr<int[]> P;
|
||||
static_assert((std::is_same<P::pointer, int*>::value), "");
|
||||
}
|
||||
{
|
||||
typedef std::unique_ptr<int[], Deleter> P;
|
||||
static_assert((std::is_same<P::pointer, Deleter::pointer>::value), "");
|
||||
}
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 default ctor
|
||||
|
||||
// default unique_ptr ctor should only require default Deleter ctor
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
#include "test_macros.h"
|
||||
|
||||
#if defined(_LIBCPP_VERSION) && TEST_STD_VER >= 11
|
||||
_LIBCPP_SAFE_STATIC std::unique_ptr<int[]> global_static_unique_ptr;
|
||||
#endif
|
||||
|
||||
class Deleter {
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const { return state_; }
|
||||
|
||||
void operator()(void*) {}
|
||||
};
|
||||
|
||||
int main() {
|
||||
{
|
||||
std::unique_ptr<int[]> p;
|
||||
assert(p.get() == 0);
|
||||
}
|
||||
{
|
||||
std::unique_ptr<int[], Deleter> p;
|
||||
assert(p.get() == 0);
|
||||
assert(p.get_deleter().state() == 5);
|
||||
}
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 default ctor
|
||||
|
||||
// default unique_ptr ctor should require default Deleter ctor
|
||||
|
||||
#include <memory>
|
||||
#include "test_macros.h"
|
||||
|
||||
class Deleter {
|
||||
Deleter() {}
|
||||
|
||||
public:
|
||||
Deleter(Deleter&) {}
|
||||
Deleter& operator=(Deleter&) { return *this; }
|
||||
|
||||
void operator()(void*) const {}
|
||||
};
|
||||
|
||||
int main() {
|
||||
#if TEST_STD_VER >= 11
|
||||
// expected-error@memory:* {{call to implicitly-deleted default constructor}}
|
||||
// expected-note@memory:* {{implicitly deleted because base class 'Deleter' has an inaccessible default constructor}}
|
||||
#else
|
||||
// expected-error@memory:* {{base class 'Deleter' has private default constructor}}
|
||||
#endif
|
||||
std::unique_ptr<int[], Deleter> p; // expected-note {{requested here}}
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 default ctor
|
||||
|
||||
// default unique_ptr ctor should require non-reference Deleter ctor
|
||||
|
||||
#include <memory>
|
||||
|
||||
class Deleter
|
||||
{
|
||||
public:
|
||||
|
||||
void operator()(void*) {}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[], Deleter&> p;
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 default ctor
|
||||
|
||||
// default unique_ptr ctor should require non-pointer Deleter
|
||||
|
||||
#include <memory>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[], void (*)(void*)> p;
|
||||
}
|
||||
@@ -1,80 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 default unique_ptr<T[]> ctor
|
||||
|
||||
// default unique_ptr<T[]> ctor shouldn't require complete type
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A;
|
||||
|
||||
class Deleter {
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const { return state_; }
|
||||
|
||||
void operator()(A* p);
|
||||
};
|
||||
|
||||
void check(int i);
|
||||
|
||||
template <class D = std::default_delete<A> >
|
||||
struct B {
|
||||
std::unique_ptr<A[], D> a_;
|
||||
B();
|
||||
~B();
|
||||
|
||||
A* get() const { return a_.get(); }
|
||||
D& get_deleter() { return a_.get_deleter(); }
|
||||
};
|
||||
|
||||
int main() {
|
||||
{
|
||||
B<> s;
|
||||
assert(s.get() == 0);
|
||||
}
|
||||
check(0);
|
||||
{
|
||||
B<Deleter> s;
|
||||
assert(s.get() == 0);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
check(0);
|
||||
}
|
||||
|
||||
struct A {
|
||||
static int count;
|
||||
A() { ++count; }
|
||||
A(const A&) { ++count; }
|
||||
~A() { --count; }
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
void Deleter::operator()(A* p) { delete p; }
|
||||
|
||||
void check(int i) { assert(A::count == i); }
|
||||
|
||||
template <class D>
|
||||
B<D>::B() {}
|
||||
|
||||
template <class D>
|
||||
B<D>::~B() {}
|
||||
@@ -1,42 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
// test move ctor. Can't copy from lvalue
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> s(new A[3]);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,70 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
// test move ctor. Should only require a MoveConstructible deleter, or if
|
||||
// deleter is a reference, not even that.
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> s(new A[3]);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = std::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 3);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
std::unique_ptr<A[], Deleter<A[]> > s(new A[3], Deleter<A[]>(5));
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2 = std::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 3);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
NCDeleter<A[]> d;
|
||||
std::unique_ptr<A[], NCDeleter<A[]>&> s(new A[3], d);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], NCDeleter<A[]>&> s2 = std::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 3);
|
||||
d.set_state(6);
|
||||
assert(s2.get_deleter().state() == d.state());
|
||||
assert(s.get_deleter().state() == d.state());
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
// test move ctor. Can't copy from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<A[]> s(new A[3]);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,72 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
// test move ctor. Should only require a MoveConstructible deleter, or if
|
||||
// deleter is a reference, not even that.
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
|
||||
std::unique_ptr<A[]>
|
||||
source1()
|
||||
{
|
||||
return std::unique_ptr<A[]>(new A[3]);
|
||||
}
|
||||
|
||||
void sink1(std::unique_ptr<A[]>)
|
||||
{
|
||||
}
|
||||
|
||||
std::unique_ptr<A[], Deleter<A[]> >
|
||||
source2()
|
||||
{
|
||||
return std::unique_ptr<A[], Deleter<A[]> >(new A[3]);
|
||||
}
|
||||
|
||||
void sink2(std::unique_ptr<A[], Deleter<A[]> >)
|
||||
{
|
||||
}
|
||||
|
||||
std::unique_ptr<A[], NCDeleter<A[]>&>
|
||||
source3()
|
||||
{
|
||||
static NCDeleter<A[]> d;
|
||||
return std::unique_ptr<A[], NCDeleter<A[]>&>(new A[3], d);
|
||||
}
|
||||
|
||||
void sink3(std::unique_ptr<A[], NCDeleter<A[]>&>)
|
||||
{
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
sink1(source1());
|
||||
sink2(source2());
|
||||
sink3(source3());
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
// test move ctor. Can't copy from lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[], Deleter> s(new A[3]);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move ctor
|
||||
|
||||
// test move ctor. Can't copy from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<A[], Deleter> s(new A[3]);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(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);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// implicit 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// Implicit version
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 = 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);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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;
|
||||
const std::unique_ptr<B[], CDeleter<A>&> s(new B, d);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], CDeleter<A>&> s2(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);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// implicit 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// Implicit version
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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;
|
||||
const std::unique_ptr<B[], CDeleter<A>&> s(new B, d);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], CDeleter<A>&> s2 = 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);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2(std::move(s));
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(std::move(s));
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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);
|
||||
}
|
||||
@@ -1,57 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// implicit 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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[]> s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[]> s2 = std::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
// Implicit version
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B[], Deleter<B[]> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2 = std::move(s);
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,78 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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);
|
||||
}
|
||||
@@ -1,46 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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
|
||||
|
||||
// unique_ptr(nullptr_t);
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
// default unique_ptr ctor should only require default Deleter ctor
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(void*) {}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<int[]> p(nullptr);
|
||||
assert(p.get() == 0);
|
||||
}
|
||||
{
|
||||
std::unique_ptr<int[], Deleter> p(nullptr);
|
||||
assert(p.get() == 0);
|
||||
assert(p.get_deleter().state() == 5);
|
||||
}
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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<T[]>(pointer) ctor
|
||||
|
||||
// unique_ptr<T[]>(pointer) ctor should require default Deleter ctor
|
||||
|
||||
#include <memory>
|
||||
|
||||
class Deleter
|
||||
{
|
||||
|
||||
Deleter() {}
|
||||
|
||||
public:
|
||||
|
||||
Deleter(Deleter&) {}
|
||||
Deleter& operator=(Deleter&) {}
|
||||
|
||||
void operator()(void*) const {}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[], Deleter> p(new int);
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer) ctor
|
||||
|
||||
// unique_ptr<T[]>(pointer) ctor should only require default Deleter ctor
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
std::unique_ptr<A[]> s(p);
|
||||
assert(s.get() == p);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
std::unique_ptr<A[], Deleter> s(p);
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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<T[]>(pointer) ctor
|
||||
|
||||
#include <memory>
|
||||
|
||||
// unique_ptr<T[]>(pointer) ctor should require non-reference Deleter ctor
|
||||
class Deleter
|
||||
{
|
||||
public:
|
||||
|
||||
void operator()(void*) {}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[], Deleter&> p(new int);
|
||||
}
|
||||
@@ -1,95 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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<T[]>(pointer) ctor
|
||||
|
||||
// unique_ptr<T[]>(pointer) ctor shouldn't require complete type
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p);
|
||||
};
|
||||
|
||||
void check(int i);
|
||||
|
||||
template <class D = std::default_delete<A[]> >
|
||||
struct B
|
||||
{
|
||||
std::unique_ptr<A[], D> a_;
|
||||
explicit B(A*);
|
||||
~B();
|
||||
|
||||
A* get() const {return a_.get();}
|
||||
D& get_deleter() {return a_.get_deleter();}
|
||||
};
|
||||
|
||||
A* get();
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = get();
|
||||
check(3);
|
||||
B<> s(p);
|
||||
assert(s.get() == p);
|
||||
}
|
||||
check(0);
|
||||
{
|
||||
A* p = get();
|
||||
check(3);
|
||||
B<Deleter> s(p);
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
check(0);
|
||||
}
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
A* get() {return new A[3];}
|
||||
|
||||
void Deleter::operator()(A* p) {delete [] p;}
|
||||
|
||||
void check(int i)
|
||||
{
|
||||
assert(A::count == i);
|
||||
}
|
||||
|
||||
template <class D>
|
||||
B<D>::B(A* a) : a_(a) {}
|
||||
|
||||
template <class D>
|
||||
B<D>::~B() {}
|
||||
@@ -1,23 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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<T[]>(pointer) ctor
|
||||
|
||||
// unique_ptr<T[]>(pointer) ctor should require non-pointer Deleter
|
||||
|
||||
#include <memory>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[], void (*)(void*)> p(new int);
|
||||
}
|
||||
@@ -1,67 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer) ctor
|
||||
|
||||
// unique_ptr(pointer) ctor should not work with derived pointers
|
||||
|
||||
#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;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(Deleter&);
|
||||
Deleter& operator=(Deleter&);
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
B* p = new B[3];
|
||||
std::unique_ptr<A[]> s(p);
|
||||
}
|
||||
{
|
||||
B* p = new B[3];
|
||||
std::unique_ptr<A[], Deleter> s(p);
|
||||
}
|
||||
}
|
||||
@@ -1,51 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr(pointer, deleter()) only requires MoveConstructible deleter
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
std::unique_ptr<A[], Deleter<A[]> > s(p, Deleter<A[]>());
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
|
||||
{ // LWG#2520 says that nullptr is a valid input as well as null
|
||||
#ifdef _LIBCPP_VERSION
|
||||
std::unique_ptr<A[], Deleter<A[]> > s1(NULL, Deleter<A[]>());
|
||||
#endif
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(nullptr, Deleter<A[]>());
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr(pointer, d) requires CopyConstructible deleter
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
void set_state(int s) {state_ = s;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], Deleter> s(p, d);
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
d.set_state(6);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], Deleter> s(nullptr, d);
|
||||
assert(s.get() == nullptr);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr<T[], D&>(pointer, d) does not requires CopyConstructible deleter
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(const Deleter&);
|
||||
Deleter& operator=(const Deleter&);
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
void set_state(int s) {state_ = s;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], Deleter&> s(p, d);
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
d.set_state(6);
|
||||
assert(s.get_deleter().state() == 6);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], Deleter&> s(nullptr, d);
|
||||
assert(s.get() == nullptr);
|
||||
}
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// XFAIL: c++98, c++03
|
||||
|
||||
// <memory>
|
||||
|
||||
// unique_ptr
|
||||
|
||||
// Test unique_ptr(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr<T, const D&>(pointer, D()) should not compile
|
||||
|
||||
#include <memory>
|
||||
|
||||
class Deleter
|
||||
{
|
||||
public:
|
||||
Deleter() {}
|
||||
void operator()(int* p) const {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
int* p = nullptr;
|
||||
std::unique_ptr<int[], const Deleter&> s(p, Deleter()); // expected-error@memory:* {{static_assert failed "rvalue deleter bound to reference"}}
|
||||
}
|
||||
@@ -1,63 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr<T[], const D&>(pointer, d) does not requires CopyConstructible deleter
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
Deleter(const Deleter&);
|
||||
Deleter& operator=(const Deleter&);
|
||||
public:
|
||||
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
void set_state(int s) {state_ = s;}
|
||||
|
||||
void operator()(A* p) const {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p = new A[3];
|
||||
assert(A::count == 3);
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], const Deleter&> s(p, d);
|
||||
assert(s.get() == p);
|
||||
assert(s.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
Deleter d;
|
||||
std::unique_ptr<A[], const Deleter&> s(nullptr, d);
|
||||
assert(s.get() == nullptr);
|
||||
}
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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(pointer, deleter) ctor
|
||||
|
||||
// unique_ptr(pointer, deleter) should not work with derived pointers
|
||||
|
||||
#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;
|
||||
|
||||
class Deleter
|
||||
{
|
||||
int state_;
|
||||
|
||||
public:
|
||||
Deleter() : state_(5) {}
|
||||
|
||||
int state() const {return state_;}
|
||||
|
||||
void operator()(A* p) {delete [] p;}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
B* p = new B[3];
|
||||
std::unique_ptr<A[], Deleter> s(p, Deleter());
|
||||
}
|
||||
@@ -1,27 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 release
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[]> p(new int[3]);
|
||||
int* i = p.get();
|
||||
int* j = p.release();
|
||||
assert(p.get() == 0);
|
||||
assert(i == j);
|
||||
delete [] j;
|
||||
}
|
||||
@@ -1,50 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 reset
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> p(new A[3]);
|
||||
assert(A::count == 3);
|
||||
A* i = p.get();
|
||||
assert(i != nullptr);
|
||||
p.reset();
|
||||
assert(A::count == 0);
|
||||
assert(p.get() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
std::unique_ptr<A[]> p(new A[4]);
|
||||
assert(A::count == 4);
|
||||
A* i = p.get();
|
||||
assert(i != nullptr);
|
||||
p.reset(new A[5]);
|
||||
assert(A::count == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,64 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 reset
|
||||
|
||||
#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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A[]> p(new A);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 0);
|
||||
A* i = p.get();
|
||||
p.reset(new B);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
{
|
||||
std::unique_ptr<A[]> p(new B);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
A* i = p.get();
|
||||
p.reset(new B);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,56 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 swap
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
int state_;
|
||||
static int count;
|
||||
A() : state_(0) {++count;}
|
||||
explicit A(int i) : state_(i) {++count;}
|
||||
A(const A& a) : state_(a.state_) {++count;}
|
||||
A& operator=(const A& a) {state_ = a.state_; return *this;}
|
||||
~A() {--count;}
|
||||
|
||||
friend bool operator==(const A& x, const A& y)
|
||||
{return x.state_ == y.state_;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
A* p1 = new A[3];
|
||||
std::unique_ptr<A[], Deleter<A[]> > s1(p1, Deleter<A[]>(1));
|
||||
A* p2 = new A[3];
|
||||
std::unique_ptr<A[], Deleter<A[]> > s2(p2, Deleter<A[]>(2));
|
||||
assert(s1.get() == p1);
|
||||
assert(s1.get_deleter().state() == 1);
|
||||
assert(s2.get() == p2);
|
||||
assert(s2.get_deleter().state() == 2);
|
||||
s1.swap(s2);
|
||||
assert(s1.get() == p2);
|
||||
assert(s1.get_deleter().state() == 2);
|
||||
assert(s2.get() == p1);
|
||||
assert(s2.get_deleter().state() == 1);
|
||||
assert(A::count == 6);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,23 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 op*()
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int[]> p(new int(3));
|
||||
assert(*p == 3);
|
||||
}
|
||||
@@ -1,39 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 op*()
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<int[]> p(new int [3]);
|
||||
if (p)
|
||||
;
|
||||
else
|
||||
assert(false);
|
||||
if (!p)
|
||||
assert(false);
|
||||
}
|
||||
{
|
||||
std::unique_ptr<int[]> p;
|
||||
if (!p)
|
||||
;
|
||||
else
|
||||
assert(false);
|
||||
if (p)
|
||||
assert(false);
|
||||
}
|
||||
}
|
||||
@@ -1,24 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 get
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
int main()
|
||||
{
|
||||
int* p = new int[3];
|
||||
std::unique_ptr<int[]> s(p);
|
||||
assert(s.get() == p);
|
||||
}
|
||||
@@ -1,58 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 get_deleter()
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
#include "test_macros.h"
|
||||
|
||||
struct Deleter {
|
||||
Deleter() {}
|
||||
|
||||
void operator()(void*) const {}
|
||||
|
||||
int test() { return 5; }
|
||||
int test() const { return 6; }
|
||||
};
|
||||
|
||||
int main() {
|
||||
{
|
||||
std::unique_ptr<int[], Deleter> p;
|
||||
assert(p.get_deleter().test() == 5);
|
||||
}
|
||||
{
|
||||
const std::unique_ptr<int[], Deleter> p;
|
||||
assert(p.get_deleter().test() == 6);
|
||||
}
|
||||
{
|
||||
typedef std::unique_ptr<int[], const Deleter&> UPtr;
|
||||
const Deleter d;
|
||||
UPtr p(nullptr, d);
|
||||
const UPtr& cp = p;
|
||||
ASSERT_SAME_TYPE(decltype(p.get_deleter()), const Deleter&);
|
||||
ASSERT_SAME_TYPE(decltype(cp.get_deleter()), const Deleter&);
|
||||
assert(p.get_deleter().test() == 6);
|
||||
assert(cp.get_deleter().test() == 6);
|
||||
}
|
||||
{
|
||||
typedef std::unique_ptr<int[], Deleter&> UPtr;
|
||||
Deleter d;
|
||||
UPtr p(nullptr, d);
|
||||
const UPtr& cp = p;
|
||||
ASSERT_SAME_TYPE(decltype(p.get_deleter()), Deleter&);
|
||||
ASSERT_SAME_TYPE(decltype(cp.get_deleter()), Deleter&);
|
||||
assert(p.get_deleter().test() == 5);
|
||||
assert(cp.get_deleter().test() == 5);
|
||||
}
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 op[](size_t)
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
class A
|
||||
{
|
||||
int state_;
|
||||
static int next_;
|
||||
public:
|
||||
A() : state_(++next_) {}
|
||||
int get() const {return state_;}
|
||||
|
||||
friend bool operator==(const A& x, int y)
|
||||
{return x.state_ == y;}
|
||||
|
||||
A& operator=(int i) {state_ = i; return *this;}
|
||||
};
|
||||
|
||||
int A::next_ = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<A[]> p(new A[3]);
|
||||
assert(p[0] == 1);
|
||||
assert(p[1] == 2);
|
||||
assert(p[2] == 3);
|
||||
p[0] = 3;
|
||||
p[1] = 2;
|
||||
p[2] = 1;
|
||||
assert(p[0] == 3);
|
||||
assert(p[1] == 2);
|
||||
assert(p[2] == 1);
|
||||
}
|
||||
@@ -1,30 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 op->()
|
||||
|
||||
#include <memory>
|
||||
#include <cassert>
|
||||
|
||||
struct A
|
||||
{
|
||||
int i_;
|
||||
|
||||
A() : i_(7) {}
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<A[]> p(new A);
|
||||
assert(p->i_ == 7);
|
||||
}
|
||||
@@ -1,55 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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::pointer type
|
||||
|
||||
#include <memory>
|
||||
#include <type_traits>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
struct Deleter
|
||||
{
|
||||
struct pointer {};
|
||||
};
|
||||
|
||||
struct D2 {
|
||||
private:
|
||||
typedef void pointer;
|
||||
};
|
||||
|
||||
struct D3 {
|
||||
static long pointer;
|
||||
};
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
typedef std::unique_ptr<int> P;
|
||||
static_assert((std::is_same<P::pointer, int*>::value), "");
|
||||
}
|
||||
{
|
||||
typedef std::unique_ptr<int, Deleter> P;
|
||||
static_assert((std::is_same<P::pointer, Deleter::pointer>::value), "");
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unique_ptr<int, D2> P;
|
||||
static_assert(std::is_same<P::pointer, int*>::value, "");
|
||||
}
|
||||
{
|
||||
typedef std::unique_ptr<int, D3> P;
|
||||
static_assert(std::is_same<P::pointer, int*>::value, "");
|
||||
}
|
||||
#endif
|
||||
}
|
||||
@@ -1,29 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
// Can't copy from lvalue
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int> s, s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
|
||||
#else
|
||||
s2 = s; // expected-error {{'operator=' is a private member}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,75 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
// test move assignment. Should only require a MoveConstructible deleter, or if
|
||||
// deleter is a reference, not even that.
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
static int count;
|
||||
A() {++count;}
|
||||
A(const A&) {++count;}
|
||||
~A() {--count;}
|
||||
};
|
||||
|
||||
int A::count = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<A> s1(new A);
|
||||
A* p = s1.get();
|
||||
std::unique_ptr<A> s2(new A);
|
||||
assert(A::count == 2);
|
||||
s2 = std::move(s1);
|
||||
assert(A::count == 1);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
std::unique_ptr<A, Deleter<A> > s1(new A, Deleter<A>(5));
|
||||
A* p = s1.get();
|
||||
std::unique_ptr<A, Deleter<A> > s2(new A);
|
||||
assert(A::count == 2);
|
||||
s2 = std::move(s1);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s1.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
{
|
||||
CDeleter<A> d1(5);
|
||||
std::unique_ptr<A, CDeleter<A>&> s1(new A, d1);
|
||||
A* p = s1.get();
|
||||
CDeleter<A> d2(6);
|
||||
std::unique_ptr<A, CDeleter<A>&> s2(new A, d2);
|
||||
s2 = std::move(s1);
|
||||
assert(s2.get() == p);
|
||||
assert(s1.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(d1.state() == 5);
|
||||
assert(d2.state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
// Can't copy from const lvalue
|
||||
|
||||
int main()
|
||||
{
|
||||
const std::unique_ptr<int> s(new int);
|
||||
std::unique_ptr<int> s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
|
||||
#else
|
||||
// NOTE: The error says "constructor" because the assignment operator takes
|
||||
// 's' by value and attempts to copy construct it.
|
||||
s2 = s; // expected-error {{no matching constructor for initialization}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,33 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
struct Deleter {
|
||||
void operator()(int* p) {delete p;}
|
||||
};
|
||||
|
||||
// Can't copy from lvalue
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<int, Deleter> s, s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
|
||||
#else
|
||||
s2 = s; // expected-error {{'operator=' is a private member}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,36 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 move assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
struct Deleter {
|
||||
void operator()(int* p) {delete p;}
|
||||
};
|
||||
|
||||
// Can't copy from a const lvalue
|
||||
int main()
|
||||
{
|
||||
const std::unique_ptr<int, Deleter> s(new int);
|
||||
std::unique_ptr<int, Deleter> s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{cannot be assigned because its copy assignment operator is implicitly deleted}}
|
||||
#else
|
||||
// NOTE: The error says "constructor" because the assignment operator takes
|
||||
// 's' by value and attempts to copy construct it.
|
||||
s2 = s; // expected-error {{no matching constructor for initialization}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,89 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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 APtr, class BPtr>
|
||||
void testAssign(APtr& aptr, BPtr& bptr) {
|
||||
A* p = bptr.get();
|
||||
assert(A::count == 2);
|
||||
aptr = std::move(bptr);
|
||||
assert(aptr.get() == p);
|
||||
assert(bptr.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
}
|
||||
|
||||
template <class LHS, class RHS>
|
||||
void checkDeleter(LHS& lhs, RHS& rhs, int LHSState, int RHSState) {
|
||||
assert(lhs.get_deleter().state() == LHSState);
|
||||
assert(rhs.get_deleter().state() == RHSState);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
std::unique_ptr<B> bptr(new B);
|
||||
std::unique_ptr<A> aptr(new A);
|
||||
testAssign(aptr, bptr);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
{
|
||||
Deleter<B> del(42);
|
||||
std::unique_ptr<B, Deleter<B> > bptr(new B, std::move(del));
|
||||
std::unique_ptr<A, Deleter<A> > aptr(new A);
|
||||
testAssign(aptr, bptr);
|
||||
checkDeleter(aptr, bptr, 42, 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
{
|
||||
CDeleter<A> adel(6);
|
||||
CDeleter<B> bdel(42);
|
||||
std::unique_ptr<B, CDeleter<B>&> bptr(new B, bdel);
|
||||
std::unique_ptr<A, CDeleter<A>&> aptr(new A, adel);
|
||||
testAssign(aptr, bptr);
|
||||
checkDeleter(aptr, bptr, 42, 42);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,42 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
A() {}
|
||||
virtual ~A() {}
|
||||
};
|
||||
|
||||
struct B : public A
|
||||
{
|
||||
};
|
||||
|
||||
// Can't assign from lvalue
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<B> s;
|
||||
std::unique_ptr<A> s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{no viable overloaded '='}}
|
||||
#else
|
||||
// NOTE: The move-semantic emulation creates an ambiguous overload set
|
||||
// so that assignment from an lvalue does not compile
|
||||
s2 = s; // expected-error {{use of overloaded operator '=' is ambiguous}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
A() {}
|
||||
virtual ~A() {}
|
||||
};
|
||||
|
||||
struct B : public A
|
||||
{
|
||||
};
|
||||
|
||||
// Can't assign from lvalue
|
||||
int main()
|
||||
{
|
||||
std::unique_ptr<B, Deleter<B> > s;
|
||||
std::unique_ptr<A, Deleter<A> > s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{no viable overloaded '='}}
|
||||
#else
|
||||
// NOTE: The move-semantic emulation creates an ambiguous overload set
|
||||
// so that assignment from an lvalue does not compile
|
||||
s2 = s; // expected-error {{use of overloaded operator '=' is ambiguous}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,47 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from lvalue
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
A() {}
|
||||
virtual ~A() {}
|
||||
};
|
||||
|
||||
struct B : public A
|
||||
{
|
||||
};
|
||||
|
||||
// Can't assign from lvalue
|
||||
int main()
|
||||
{
|
||||
Deleter<B> db;
|
||||
std::unique_ptr<B, Deleter<B>& > s(new B, db);
|
||||
Deleter<A> da;
|
||||
std::unique_ptr<A, Deleter<A> &> s2(new A, da);
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{no viable overloaded '='}}
|
||||
#else
|
||||
// NOTE: The move-semantic emulation creates an ambiguous overload set
|
||||
// so that assignment from an lvalue does not compile
|
||||
s2 = s; // expected-error {{use of overloaded operator '=' is ambiguous}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,43 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
#include <memory>
|
||||
|
||||
#include "test_macros.h"
|
||||
#include "deleter_types.h"
|
||||
|
||||
struct A
|
||||
{
|
||||
A() {}
|
||||
virtual ~A() {}
|
||||
};
|
||||
|
||||
struct B : public A
|
||||
{
|
||||
};
|
||||
|
||||
// Can't assign from lvalue
|
||||
int main()
|
||||
{
|
||||
const std::unique_ptr<B> s(new B);
|
||||
std::unique_ptr<A> s2;
|
||||
#if TEST_STD_VER >= 11
|
||||
s2 = s; // expected-error {{no viable overloaded '='}}
|
||||
#else
|
||||
// NOTE: The error says "constructor" because the assignment operator takes
|
||||
// 's' by value and attempts to copy construct it.
|
||||
s2 = s; // expected-error {{no matching constructor for initialization}}
|
||||
#endif
|
||||
}
|
||||
@@ -1,61 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
const std::unique_ptr<B, Deleter<B> > s(new B);
|
||||
A* p = s.get();
|
||||
std::unique_ptr<A, Deleter<A> > s2;
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
assert(s.get_deleter().state() == 0);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
@@ -1,62 +0,0 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// 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 assignment
|
||||
|
||||
// Can't assign from const lvalue
|
||||
|
||||
#include <memory>
|
||||
#include <utility>
|
||||
#include <cassert>
|
||||
|
||||
#include "deleter_types.h"
|
||||
|
||||
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;
|
||||
|
||||
int main()
|
||||
{
|
||||
{
|
||||
Deleter<B> db(5);
|
||||
const std::unique_ptr<B, Deleter<B>&> s(new B, db);
|
||||
A* p = s.get();
|
||||
Deleter<A> da(6);
|
||||
std::unique_ptr<A, Deleter<A>&> s2(new A, da);
|
||||
s2 = s;
|
||||
assert(s2.get() == p);
|
||||
assert(s.get() == 0);
|
||||
assert(A::count == 1);
|
||||
assert(B::count == 1);
|
||||
assert(s2.get_deleter().state() == 5);
|
||||
}
|
||||
assert(A::count == 0);
|
||||
assert(B::count == 0);
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user