update sources to v12.2.3

[ceph.git] / ceph / src / boost / libs / smart_ptr / test / allocate_shared_array_throws_test.cpp

diff --git a/ceph/src/boost/libs/smart_ptr/test/allocate_shared_array_throws_test.cpp b/ceph/src/boost/libs/smart_ptr/test/allocate_shared_array_throws_test.cpp
index e14d98421fcdb9bc2dc8c4b5e3826f76459ec4f2..dd674bbc82e559bff96f319e253129f479a14238 100644 (file)
--- a/ceph/src/boost/libs/smart_ptr/test/allocate_shared_array_throws_test.cpp
+++ b/ceph/src/boost/libs/smart_ptr/test/allocate_shared_array_throws_test.cpp
@@ -1,79 +1,118 @@
 /*
-(c) 2012-2015 Glen Joseph Fernandes
-<glenjofe -at- gmail.com>
+Copyright 2012-2015 Glen Joseph Fernandes
+(glenjofe@gmail.com)
 
-Distributed under the Boost Software
-License, Version 1.0.
-http://boost.org/LICENSE_1_0.txt
+Distributed under the Boost Software License, Version 1.0.
+(http://www.boost.org/LICENSE_1_0.txt)
 */
 #include <boost/core/lightweight_test.hpp>
 #include <boost/smart_ptr/make_shared.hpp>
 
+template<class T = void>
+struct creator {
+    typedef T value_type;
+
+    template<class U>
+    struct rebind {
+        typedef creator<U> other;
+    };
+
+    creator() { }
+
+    template<class U>
+    creator(const creator<U>&) { }
+
+    T* allocate(std::size_t size) {
+        return static_cast<T*>(::operator new(sizeof(T) * size));
+    }
+
+    void deallocate(T* ptr, std::size_t) {
+        ::operator delete(ptr);
+    }
+};
+
+template<class T, class U>
+inline bool
+operator==(const creator<T>&, const creator<U>&)
+{
+    return true;
+}
+
+template<class T, class U>
+inline bool
+operator!=(const creator<T>&, const creator<U>&)
+{
+    return false;
+}
+
 class type {
 public:
-    static unsigned int instances;
-    explicit type() {
+    static unsigned instances;
+
+    type() {
         if (instances == 5) {
             throw true;
         }
-        instances++;
+        ++instances;
     }
+
     ~type() {
-        instances--;
+        --instances;
     }
+
 private:
     type(const type&);
     type& operator=(const type&);
 };
 
-unsigned int type::instances = 0;
+unsigned type::instances = 0;
 
 int main()
 {
     try {
-        boost::allocate_shared<type[]>(std::allocator<type>(), 6);
+        boost::allocate_shared<type[]>(creator<type>(), 6);
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[][2]>(std::allocator<type>(), 3);
+        boost::allocate_shared<type[][2]>(creator<type>(), 3);
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[6]>(std::allocator<type>());
+        boost::allocate_shared<type[6]>(creator<>());
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared<type[3][2]>(std::allocator<type>());
+        boost::allocate_shared<type[3][2]>(creator<>());
         BOOST_ERROR("allocate_shared did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
+        boost::allocate_shared_noinit<type[]>(creator<>(), 6);
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
+        boost::allocate_shared_noinit<type[][2]>(creator<>(), 3);
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[6]>(std::allocator<type>());
+        boost::allocate_shared_noinit<type[6]>(creator<>());
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);
     }
     try {
-        boost::allocate_shared_noinit<type[3][2]>(std::allocator<type>());
+        boost::allocate_shared_noinit<type[3][2]>(creator<>());
         BOOST_ERROR("allocate_shared_noinit did not throw");
     } catch (...) {
         BOOST_TEST(type::instances == 0);