This is an archive of the discontinued LLVM Phabricator instance.

Differential D81532

[libcxx] Add compatible with constraint tests for some shared_ptr constructors.
ClosedPublic

Authored by zoecarver on Jun 9 2020, 9:59 PM.

Details

Reviewers
ldionne
Group Reviewers
Restricted Project
Commits
rG8697d6cfa894: [libcxx] Add compatible with constraint tests for some shared_ptr constructors.
Summary

Add shared_ptr tests where the element type and pointer type aren't 'convertible' but are 'compatible'.

Responding to a comment from D81414.

Diff Detail

Event Timeline

zoecarver created this revision.Jun 9 2020, 9:59 PM
Herald added a project: Restricted Project. · View Herald TranscriptJun 9 2020, 9:59 PM
Herald added a reviewer: Restricted Project. · View Herald Transcript
Herald added subscribers: libcxx-commits, dexonsmith. · View Herald Transcript
Harbormaster failed remote builds in B59738: Diff 269735!Jun 9 2020, 11:06 PM
zoecarver added a comment.Jun 23 2020, 8:32 PM

Ping. This is a NFC.

dexonsmith removed a subscriber: dexonsmith.Jun 24 2020, 3:29 PM
ldionne accepted this revision.Jul 28 2020, 5:54 AM
This revision is now accepted and ready to land.Jul 28 2020, 5:54 AM
This revision was landed with ongoing or failed builds.Aug 1 2020, 12:07 PM
Closed by commit rG8697d6cfa894: [libcxx] Add compatible with constraint tests for some shared_ptr constructors. (authored by zoecarver). · Explain Why
This revision was automatically updated to reflect the committed changes.
zoecarver added a commit: rG8697d6cfa894: [libcxx] Add compatible with constraint tests for some shared_ptr constructors..

Revision Contents

PathSize
libcxx/
test/
std/
utilities/
memory/
util.smartptr/
util.smartptr.shared/
util.smartptr.shared.const/
9 lines
10 lines

Diff 282408

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter.pass.cpp

Show All 22 Linesstruct A
A() {++count;} A() {++count;}
A(const A&) {++count;} A(const A&) {++count;}
~A() {--count;} ~A() {--count;}
}; };
int A::count = 0; int A::count = 0;
struct Base { };
struct Derived : Base { };
int main(int, char**) int main(int, char**)
{ {
{ {
A* ptr = new A; A* ptr = new A;
std::shared_ptr<A> p(ptr, test_deleter<A>(3)); std::shared_ptr<A> p(ptr, test_deleter<A>(3));
assert(A::count == 1); assert(A::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
assert(p.get() == ptr); assert(p.get() == ptr);
test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p); test_deleter<A>* d = std::get_deleter<test_deleter<A> >(p);
assert(test_deleter<A>::count == 1); assert(test_deleter<A>::count == 1);
assert(test_deleter<A>::dealloc_count == 0); assert(test_deleter<A>::dealloc_count == 0);
assert(d); assert(d);
assert(d->state() == 3); assert(d->state() == 3);
} }
assert(A::count == 0); assert(A::count == 0);
assert(test_deleter<A>::count == 0); assert(test_deleter<A>::count == 0);
assert(test_deleter<A>::dealloc_count == 1); assert(test_deleter<A>::dealloc_count == 1);
{
// Make sure that we can construct a shared_ptr where the element type and pointer type
// aren't "convertible" but are "compatible".
static_assert(!std::is_constructible<std::shared_ptr<Derived[4]>, Base[4], test_deleter<Derived[4]> >::value, "");
}
return 0; return 0;
} }

libcxx/test/std/utilities/memory/util.smartptr/util.smartptr.shared/util.smartptr.shared.const/pointer_deleter_allocator.pass.cpp

Show All 22 Linesstruct A
A() {++count;} A() {++count;}
A(const A&) {++count;} A(const A&) {++count;}
~A() {--count;} ~A() {--count;}
}; };
int A::count = 0; int A::count = 0;
struct Base { };
struct Derived : Base { };
int main(int, char**) int main(int, char**)
{ {
{ {
A* ptr = new A; A* ptr = new A;
std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5)); std::shared_ptr<A> p(ptr, test_deleter<A>(3), test_allocator<A>(5));
assert(A::count == 1); assert(A::count == 1);
assert(p.use_count() == 1); assert(p.use_count() == 1);
▲ Show 20 Lines • Show All 43 Lines • ▼ Show 20 Lines#if TEST_STD_VER >= 11
assert(d); assert(d);
assert(d->state() == 3); assert(d->state() == 3);
} }
assert(A::count == 0); assert(A::count == 0);
assert(test_deleter<A>::count == 0); assert(test_deleter<A>::count == 0);
assert(test_deleter<A>::dealloc_count == 1); assert(test_deleter<A>::dealloc_count == 1);
#endif #endif
{
// Make sure that we can construct a shared_ptr where the element type and pointer type
// aren't "convertible" but are "compatible".
static_assert(!std::is_constructible<std::shared_ptr<Derived[4]>,
Base[4], test_deleter<Derived[4]>,
test_allocator<Derived[4]> >::value, "");
}
return 0; return 0;
} }