LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Mark LWG issue 2565 as complete. Update the tests to check it.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@271238 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2016-05-31 00:23:31 +00:00
parent efa8e8868c
commit 979137793e
3 changed files with 101 additions and 29 deletions
Download Patch File Download Diff File Expand all files Collapse all files

66
test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp
View File

@@ -7,6 +7,8 @@
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03
// <functional>
// class function<R(ArgTypes...)>
@@ -14,8 +16,10 @@
// template<class A> function(allocator_arg_t, const A&, function&&);
#include <functional>
#include <memory>
#include <cassert>
#include "test_macros.h"
#include "min_allocator.h"
#include "count_new.hpp"
@@ -46,23 +50,57 @@ public:
int A::count = 0;
int g(int) { return 0; }
int main()
{
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
assert(globalMemCounter.checkOutstandingNewEq(0));
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2(std::allocator_arg, bare_allocator<A>(), std::move(f));
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f = A();
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2(std::allocator_arg, bare_allocator<A>(), std::move(f));
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
}
assert(globalMemCounter.checkOutstandingNewEq(0));
{
// Test that moving a function constructed from a reference wrapper
// is done without allocating.
DisableAllocationGuard g;
using Ref = std::reference_wrapper<A>;
A a;
Ref aref(a);
std::function<int(int)> f(aref);
assert(A::count == 1);
assert(f.target<A>() == nullptr);
assert(f.target<Ref>());
std::function<int(int)> f2(std::allocator_arg, std::allocator<void>{},
std::move(f));
assert(A::count == 1);
assert(f2.target<A>() == nullptr);
assert(f2.target<Ref>());
assert(f.target<Ref>()); // f is unchanged because the target is small
}
{
// Test that moving a function constructed from a function pointer
// is done without allocating
DisableAllocationGuard guard;
using Ptr = int(*)(int);
Ptr p = g;
std::function<int(int)> f(p);
assert(f.target<A>() == nullptr);
assert(f.target<Ptr>());
std::function<int(int)> f2(std::allocator_arg, std::allocator<void>(),
std::move(f));
assert(f2.target<A>() == nullptr);
assert(f2.target<Ptr>());
assert(f.target<Ptr>()); // f is unchanged because the target is small
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
}

62
test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp → test/std/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_move.pass.cpp
View File

@@ -14,9 +14,11 @@
// function(const function& f);
#include <functional>
#include <memory>
#include <cstdlib>
#include <cassert>
#include "test_macros.h"
#include "count_new.hpp"
class A
@@ -98,21 +100,53 @@ int main()
assert(g.target<A>() == 0);
assert(!g);
}
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
#if TEST_STD_VER >= 11
assert(globalMemCounter.checkOutstandingNewEq(0));
{ // Test rvalue references
std::function<int(int)> f = A();
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2 = std::move(f);
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
}
assert(globalMemCounter.checkOutstandingNewEq(0));
{
std::function<int(int)> f = A();
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f.target<A>());
assert(f.target<int(*)(int)>() == 0);
std::function<int(int)> f2 = std::move(f);
assert(A::count == 1);
assert(globalMemCounter.checkOutstandingNewEq(1));
assert(f2.target<A>());
assert(f2.target<int(*)(int)>() == 0);
assert(f.target<A>() == 0);
assert(f.target<int(*)(int)>() == 0);
// Test that moving a function constructed from a reference wrapper
// is done without allocating.
DisableAllocationGuard g;
using Ref = std::reference_wrapper<A>;
A a;
Ref aref(a);
std::function<int(int)> f(aref);
assert(A::count == 1);
assert(f.target<A>() == nullptr);
assert(f.target<Ref>());
std::function<int(int)> f2(std::move(f));
assert(A::count == 1);
assert(f2.target<A>() == nullptr);
assert(f2.target<Ref>());
assert(f.target<Ref>()); // f is unchanged because the target is small
}
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
{
// Test that moving a function constructed from a function pointer
// is done without allocating
DisableAllocationGuard guard;
using Ptr = int(*)(int);
Ptr p = g;
std::function<int(int)> f(p);
assert(f.target<A>() == nullptr);
assert(f.target<Ptr>());
std::function<int(int)> f2(std::move(f));
assert(f2.target<A>() == nullptr);
assert(f2.target<Ptr>());
assert(f.target<Ptr>()); // f is unchanged because the target is small
}
#endif // TEST_STD_VER >= 11
}