Installed allocator into std::function

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111672 91177308-0d34-0410-b5e6-96231b3b80d8

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp

@@ -16,7 +16,10 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&); not implemented
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int>());
+    assert(!f);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

@@ -16,7 +16,65 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+
+    int foo(int) const {return 1;}
+};
+
+int A::count = 0;
+
+int g(int) {return 0;}
+
 int main()
 {
-#error template<class F, class A> function(allocator_arg_t, const A&, F); not implemented
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<A>(), A());
+    assert(A::count == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    }
+    assert(A::count == 0);
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int(*)(int)>(), g);
+    assert(f.target<int(*)(int)>());
+    assert(f.target<A>() == 0);
+    }
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int(*)(int)>(),
+                              (int (*)(int))0);
+    assert(!f);
+    assert(f.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    }
+    {
+    std::function<int(const A*, int)> f(std::allocator_arg,
+                                        test_allocator<int(A::*)(int)const>(),
+                                        &A::foo);
+    assert(f);
+    assert(f.target<int (A::*)(int) const>() != 0);
+    }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp

@@ -14,9 +14,91 @@
 // template<class A> function(allocator_arg_t, const A&, const function&);
 
 #include <functional>
+#include <new>
+#include <cstdlib>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+};
+
+int A::count = 0;
+
+int g(int) {return 0;}
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, const function&); not implemented
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = A();
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), f);
+    assert(A::count == 2);
+    assert(new_called == 2);
+    assert(f2.target<A>());
+    assert(f2.target<int(*)(int)>() == 0);
+    }
+    assert(A::count == 0);
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = g;
+    assert(new_called == 0);
+    assert(f.target<int(*)(int)>());
+    assert(f.target<A>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<int(*)(int)>(), f);
+    assert(new_called == 0);
+    assert(f2.target<int(*)(int)>());
+    assert(f2.target<A>() == 0);
+    }
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f;
+    assert(new_called == 0);
+    assert(f.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<int>(), f);
+    assert(new_called == 0);
+    assert(f2.target<int(*)(int)>() == 0);
+    assert(f2.target<A>() == 0);
+    }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp

@@ -16,7 +16,10 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, nullptr_t); not implemented
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int>(), nullptr);
+    assert(!f);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

@@ -16,7 +16,66 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+};
+
+int A::count = 0;
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, function&&); not implemented
+#ifdef _LIBCPP_MOVE
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = A();
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), std::move(f));
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f2.target<A>());
+    assert(f2.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    assert(f.target<int(*)(int)>() == 0);
+    }
+#endif
 }