forked from boostorg/smart_ptr
Update make_shared for arrays to conform to N3870
Update make_shared and allocate_shared for arrays to be confined to the set of overloads specified in N3870.
This commit is contained in:
Glen Fernandes
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -14,9 +14,6 @@
|
||||
#include <boost/smart_ptr/detail/array_deleter.hpp>
|
||||
#include <boost/smart_ptr/detail/array_traits.hpp>
|
||||
#include <boost/smart_ptr/detail/sp_if_array.hpp>
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
#include <initializer_list>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
template<typename T, typename A>
|
||||
@ -36,67 +33,27 @@ namespace boost {
|
||||
d2->init(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename T, typename A, typename... Args>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
allocate_shared(const A& allocator, std::size_t size, Args&&... args) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
std::size_t n1 = size * boost::detail::array_total<T1>::size;
|
||||
boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<Args>(args)...);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
template<typename T, typename A, typename... Args>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
allocate_shared(const A& allocator, Args&&... args) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<Args>(args)...);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
allocate_shared(const A& allocator, const T& list) {
|
||||
allocate_shared(const A& allocator) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
typedef const T2 T3;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
T3* p3 = 0;
|
||||
boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init_list(p2, p3);
|
||||
d2->init(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
allocate_shared(const A& allocator, std::size_t size,
|
||||
@ -115,12 +72,13 @@ namespace boost {
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p3 = reinterpret_cast<T3*>(&list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->template init_list<M>(p2, p3);
|
||||
d2->template init<M>(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
allocate_shared(const A& allocator,
|
||||
@ -139,76 +97,13 @@ namespace boost {
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p3 = reinterpret_cast<T3*>(&list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->template init_list<M>(p2, p3);
|
||||
d2->template init<M>(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
allocate_shared(const A& allocator,
|
||||
std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
typedef const T2 T3;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
T3* p3 = 0;
|
||||
std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
|
||||
boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list.begin());
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init_list(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
allocate_shared(const A& allocator, std::size_t size,
|
||||
typename boost::detail::array_base<T>::type&& value) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
std::size_t n1 = size * boost::detail::array_total<T1>::size;
|
||||
boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<T2>(value));
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
allocate_shared(const A& allocator,
|
||||
typename boost::detail::array_base<T>::type&& value) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<T2>(value));
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
allocate_shared_noinit(const A& allocator, std::size_t size) {
|
||||
@ -226,6 +121,7 @@ namespace boost {
|
||||
d2->noinit(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T, typename A>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
allocate_shared_noinit(const A& allocator) {
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -15,12 +15,15 @@ namespace boost {
|
||||
namespace detail {
|
||||
template<typename A, typename T, typename Y = char>
|
||||
class allocate_array_helper;
|
||||
|
||||
template<typename A, typename T, typename Y>
|
||||
class allocate_array_helper<A, T[], Y> {
|
||||
template<typename A9, typename T9, typename Y9>
|
||||
friend class allocate_array_helper;
|
||||
|
||||
typedef typename A::template rebind<Y> ::other A2;
|
||||
typedef typename A::template rebind<char>::other A3;
|
||||
|
||||
public:
|
||||
typedef typename A2::value_type value_type;
|
||||
typedef typename A2::pointer pointer;
|
||||
@ -29,30 +32,37 @@ namespace boost {
|
||||
typedef typename A2::const_reference const_reference;
|
||||
typedef typename A2::size_type size_type;
|
||||
typedef typename A2::difference_type difference_type;
|
||||
|
||||
template<typename U>
|
||||
struct rebind {
|
||||
typedef allocate_array_helper<A, T[], U> other;
|
||||
};
|
||||
|
||||
allocate_array_helper(const A& allocator_, std::size_t size_, T** data_)
|
||||
: allocator(allocator_),
|
||||
size(sizeof(T) * size_),
|
||||
data(data_) {
|
||||
}
|
||||
|
||||
template<class U>
|
||||
allocate_array_helper(const allocate_array_helper<A, T[], U>& other)
|
||||
: allocator(other.allocator),
|
||||
size(other.size),
|
||||
data(other.data) {
|
||||
}
|
||||
|
||||
pointer address(reference value) const {
|
||||
return allocator.address(value);
|
||||
}
|
||||
|
||||
const_pointer address(const_reference value) const {
|
||||
return allocator.address(value);
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return allocator.max_size();
|
||||
}
|
||||
|
||||
pointer allocate(size_type count, const void* value = 0) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
@ -64,37 +74,46 @@ namespace boost {
|
||||
*data = reinterpret_cast<T*>(p2);
|
||||
return reinterpret_cast<Y*>(p1);
|
||||
}
|
||||
|
||||
void deallocate(pointer memory, size_type count) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
char* p1 = reinterpret_cast<char*>(memory);
|
||||
A3(allocator).deallocate(p1, n1 + size);
|
||||
}
|
||||
|
||||
void construct(pointer memory, const Y& value) {
|
||||
allocator.construct(memory, value);
|
||||
}
|
||||
|
||||
void destroy(pointer memory) {
|
||||
allocator.destroy(memory);
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator==(const allocate_array_helper<A, T[], U>& other) const {
|
||||
return allocator == other.allocator;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator!=(const allocate_array_helper<A, T[], U>& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
private:
|
||||
A2 allocator;
|
||||
std::size_t size;
|
||||
T** data;
|
||||
};
|
||||
|
||||
template<typename A, typename T, std::size_t N, typename Y>
|
||||
class allocate_array_helper<A, T[N], Y> {
|
||||
template<typename A9, typename T9, typename Y9>
|
||||
friend class allocate_array_helper;
|
||||
|
||||
typedef typename A::template rebind<Y> ::other A2;
|
||||
typedef typename A::template rebind<char>::other A3;
|
||||
|
||||
public:
|
||||
typedef typename A2::value_type value_type;
|
||||
typedef typename A2::pointer pointer;
|
||||
@ -103,28 +122,35 @@ namespace boost {
|
||||
typedef typename A2::const_reference const_reference;
|
||||
typedef typename A2::size_type size_type;
|
||||
typedef typename A2::difference_type difference_type;
|
||||
|
||||
template<typename U>
|
||||
struct rebind {
|
||||
typedef allocate_array_helper<A, T[N], U> other;
|
||||
};
|
||||
|
||||
allocate_array_helper(const A& allocator_, T** data_)
|
||||
: allocator(allocator_),
|
||||
data(data_) {
|
||||
}
|
||||
|
||||
template<class U>
|
||||
allocate_array_helper(const allocate_array_helper<A, T[N], U>& other)
|
||||
: allocator(other.allocator),
|
||||
data(other.data) {
|
||||
}
|
||||
|
||||
pointer address(reference value) const {
|
||||
return allocator.address(value);
|
||||
}
|
||||
|
||||
const_pointer address(const_reference value) const {
|
||||
return allocator.address(value);
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return allocator.max_size();
|
||||
}
|
||||
|
||||
pointer allocate(size_type count, const void* value = 0) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
@ -136,30 +162,37 @@ namespace boost {
|
||||
*data = reinterpret_cast<T*>(p2);
|
||||
return reinterpret_cast<Y*>(p1);
|
||||
}
|
||||
|
||||
void deallocate(pointer memory, size_type count) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
char* p1 = reinterpret_cast<char*>(memory);
|
||||
A3(allocator).deallocate(p1, n1 + N1);
|
||||
}
|
||||
|
||||
void construct(pointer memory, const Y& value) {
|
||||
allocator.construct(memory, value);
|
||||
}
|
||||
|
||||
void destroy(pointer memory) {
|
||||
allocator.destroy(memory);
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator==(const allocate_array_helper<A, T[N], U>& other) const {
|
||||
return allocator == other.allocator;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator!=(const allocate_array_helper<A, T[N], U>& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
private:
|
||||
enum {
|
||||
N1 = N * sizeof(T)
|
||||
};
|
||||
|
||||
A2 allocator;
|
||||
T** data;
|
||||
};
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -10,12 +10,12 @@
|
||||
#define BOOST_SMART_PTR_DETAIL_ARRAY_DELETER_HPP
|
||||
|
||||
#include <boost/smart_ptr/detail/array_utility.hpp>
|
||||
#include <boost/smart_ptr/detail/sp_forward.hpp>
|
||||
|
||||
namespace boost {
|
||||
namespace detail {
|
||||
template<typename T>
|
||||
class array_deleter;
|
||||
|
||||
template<typename T>
|
||||
class array_deleter<T[]> {
|
||||
public:
|
||||
@ -23,98 +23,77 @@ namespace boost {
|
||||
: size(size_),
|
||||
object(0) {
|
||||
}
|
||||
|
||||
~array_deleter() {
|
||||
if (object) {
|
||||
array_destroy(object, size);
|
||||
}
|
||||
}
|
||||
|
||||
void init(T* memory) {
|
||||
array_init(memory, size);
|
||||
object = memory;
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
void init(T* memory, T&& value) {
|
||||
array_init_value(memory, size, sp_forward<T>(value));
|
||||
object = memory;
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
template<typename... Args>
|
||||
void init(T* memory, Args&&... args) {
|
||||
array_init_args(memory, size, sp_forward<Args>(args)...);
|
||||
object = memory;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
void init_list(T* memory, const T* list) {
|
||||
array_init_list(memory, size, list);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
template<std::size_t M>
|
||||
void init_list(T* memory, const T* list) {
|
||||
array_init_list<T, M>(memory, size, list);
|
||||
void init(T* memory, const T* list) {
|
||||
array_init<T, M>(memory, size, list);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
void noinit(T* memory) {
|
||||
array_noinit(memory, size);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
void operator()(const void*) {
|
||||
if (object) {
|
||||
array_destroy(object, size);
|
||||
object = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
std::size_t size;
|
||||
T* object;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
class array_deleter<T[N]> {
|
||||
public:
|
||||
array_deleter()
|
||||
: object(0) {
|
||||
}
|
||||
|
||||
~array_deleter() {
|
||||
if (object) {
|
||||
array_destroy(object, N);
|
||||
}
|
||||
}
|
||||
|
||||
void init(T* memory) {
|
||||
array_init(memory, N);
|
||||
object = memory;
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
void init(T* memory, T&& value) {
|
||||
array_init_value(memory, N, sp_forward<T>(value));
|
||||
object = memory;
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
template<typename... Args>
|
||||
void init(T* memory, Args&&... args) {
|
||||
array_init_args(memory, N, sp_forward<Args>(args)...);
|
||||
object = memory;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
void init_list(T* memory, const T* list) {
|
||||
array_init_list(memory, N, list);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
template<std::size_t M>
|
||||
void init_list(T* memory, const T* list) {
|
||||
array_init_list<T, M>(memory, N, list);
|
||||
void init(T* memory, const T* list) {
|
||||
array_init<T, M>(memory, N, list);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
void noinit(T* memory) {
|
||||
array_noinit(memory, N);
|
||||
object = memory;
|
||||
}
|
||||
|
||||
void operator()(const void*) {
|
||||
if (object) {
|
||||
array_destroy(object, N);
|
||||
object = 0;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
T* object;
|
||||
};
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -17,32 +17,39 @@ namespace boost {
|
||||
struct array_base {
|
||||
typedef typename boost::remove_cv<T>::type type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct array_base<T[]> {
|
||||
typedef typename array_base<T>::type type;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct array_base<T[N]> {
|
||||
typedef typename array_base<T>::type type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct array_total {
|
||||
enum {
|
||||
size = 1
|
||||
};
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct array_total<T[N]> {
|
||||
enum {
|
||||
size = N * array_total<T>::size
|
||||
};
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct array_inner;
|
||||
|
||||
template<typename T>
|
||||
struct array_inner<T[]> {
|
||||
typedef T type;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct array_inner<T[N]> {
|
||||
typedef T type;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -18,25 +18,30 @@ namespace boost {
|
||||
template<typename T>
|
||||
inline void array_destroy(T*, std::size_t, boost::true_type) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_destroy(T* memory, std::size_t size, boost::false_type) {
|
||||
for (std::size_t i = size; i > 0; ) {
|
||||
memory[--i].~T();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_destroy(T* memory, std::size_t size) {
|
||||
boost::has_trivial_destructor<T> type;
|
||||
array_destroy(memory, size, type);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_init(T* memory, std::size_t size, boost::true_type) {
|
||||
inline void array_value(T* memory, std::size_t size, boost::true_type) {
|
||||
for (std::size_t i = 0; i < size; i++) {
|
||||
memory[i] = T();
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T();
|
||||
}
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_init(T* memory, std::size_t size, boost::false_type) {
|
||||
inline void array_value(T* memory, std::size_t size, boost::false_type) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
@ -55,77 +60,15 @@ namespace boost {
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_init(T* memory, std::size_t size) {
|
||||
boost::has_trivial_default_constructor<T> type;
|
||||
array_init(memory, size, type);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename T>
|
||||
inline void array_init_value(T* memory, std::size_t size, T&& value) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
for (; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(value);
|
||||
}
|
||||
} catch (...) {
|
||||
array_destroy(memory, i);
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
for (std::size_t i = 0; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(value);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
|
||||
template<typename T, typename... Args>
|
||||
inline void array_init_args(T* memory, std::size_t size, Args&&... args) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
for (; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(args...);
|
||||
}
|
||||
} catch (...) {
|
||||
array_destroy(memory, i);
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
for (std::size_t i = 0; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(args...);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
template<typename T>
|
||||
inline void array_init_list(T* memory, std::size_t size, const T* list) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
for (; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(list[i]);
|
||||
}
|
||||
} catch (...) {
|
||||
array_destroy(memory, i);
|
||||
throw;
|
||||
}
|
||||
#else
|
||||
for (std::size_t i = 0; i < size; i++) {
|
||||
void* p1 = memory + i;
|
||||
::new(p1) T(list[i]);
|
||||
}
|
||||
#endif
|
||||
array_value(memory, size, type);
|
||||
}
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
inline void array_init_list(T* memory, std::size_t size, const T* list) {
|
||||
inline void array_init(T* memory, std::size_t size, const T* list) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
@ -144,11 +87,13 @@ namespace boost {
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_noinit(T*, std::size_t, boost::true_type) {
|
||||
inline void array_default(T*, std::size_t, boost::true_type) {
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_noinit(T* memory, std::size_t size, boost::false_type) {
|
||||
inline void array_default(T* memory, std::size_t size, boost::false_type) {
|
||||
#if !defined(BOOST_NO_EXCEPTIONS)
|
||||
std::size_t i = 0;
|
||||
try {
|
||||
@ -167,10 +112,11 @@ namespace boost {
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline void array_noinit(T* memory, std::size_t size) {
|
||||
boost::has_trivial_default_constructor<T> type;
|
||||
array_noinit(memory, size, type);
|
||||
array_default(memory, size, type);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2104 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -15,10 +15,12 @@ namespace boost {
|
||||
namespace detail {
|
||||
template<typename T, typename Y = char>
|
||||
class make_array_helper;
|
||||
|
||||
template<typename T, typename Y>
|
||||
class make_array_helper<T[], Y> {
|
||||
template<typename T2, typename Y2>
|
||||
friend class make_array_helper;
|
||||
|
||||
public:
|
||||
typedef Y value_type;
|
||||
typedef Y* pointer;
|
||||
@ -27,28 +29,35 @@ namespace boost {
|
||||
typedef const Y& const_reference;
|
||||
typedef std::size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
template<typename U>
|
||||
struct rebind {
|
||||
typedef make_array_helper<T[], U> other;
|
||||
};
|
||||
|
||||
make_array_helper(std::size_t size_, T** data_)
|
||||
: size(sizeof(T) * size_),
|
||||
data(data_) {
|
||||
}
|
||||
|
||||
template<class U>
|
||||
make_array_helper(const make_array_helper<T[], U>& other)
|
||||
: size(other.size),
|
||||
data(other.data) {
|
||||
}
|
||||
|
||||
pointer address(reference value) const {
|
||||
return &value;
|
||||
}
|
||||
|
||||
const_pointer address(const_reference value) const {
|
||||
return &value;
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return static_cast<std::size_t>(-1) / sizeof(Y);
|
||||
}
|
||||
|
||||
pointer allocate(size_type count, const void* = 0) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
@ -60,33 +69,41 @@ namespace boost {
|
||||
*data = reinterpret_cast<T*>(p2);
|
||||
return reinterpret_cast<Y*>(p1);
|
||||
}
|
||||
|
||||
void deallocate(pointer memory, size_type) {
|
||||
void* p1 = memory;
|
||||
::operator delete(p1);
|
||||
}
|
||||
|
||||
void construct(pointer memory, const Y& value) {
|
||||
void* p1 = memory;
|
||||
::new(p1) Y(value);
|
||||
}
|
||||
|
||||
void destroy(pointer memory) {
|
||||
memory->~Y();
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator==(const make_array_helper<T[], U>&) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator!=(const make_array_helper<T[], U>& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
private:
|
||||
std::size_t size;
|
||||
T** data;
|
||||
};
|
||||
|
||||
template<typename T, std::size_t N, typename Y>
|
||||
class make_array_helper<T[N], Y> {
|
||||
template<typename T2, typename Y2>
|
||||
friend class make_array_helper;
|
||||
|
||||
public:
|
||||
typedef Y value_type;
|
||||
typedef Y* pointer;
|
||||
@ -95,26 +112,33 @@ namespace boost {
|
||||
typedef const Y& const_reference;
|
||||
typedef std::size_t size_type;
|
||||
typedef ptrdiff_t difference_type;
|
||||
|
||||
template<typename U>
|
||||
struct rebind {
|
||||
typedef make_array_helper<T[N], U> other;
|
||||
};
|
||||
|
||||
make_array_helper(T** data_)
|
||||
: data(data_) {
|
||||
}
|
||||
|
||||
template<class U>
|
||||
make_array_helper(const make_array_helper<T[N], U>& other)
|
||||
: data(other.data) {
|
||||
}
|
||||
|
||||
pointer address(reference value) const {
|
||||
return &value;
|
||||
}
|
||||
|
||||
const_pointer address(const_reference value) const {
|
||||
return &value;
|
||||
}
|
||||
|
||||
size_type max_size() const {
|
||||
return static_cast<std::size_t>(-1) / sizeof(Y);
|
||||
}
|
||||
|
||||
pointer allocate(size_type count, const void* = 0) {
|
||||
std::size_t a1 = boost::alignment_of<T>::value;
|
||||
std::size_t n1 = count * sizeof(Y) + a1 - 1;
|
||||
@ -126,29 +150,36 @@ namespace boost {
|
||||
*data = reinterpret_cast<T*>(p2);
|
||||
return reinterpret_cast<Y*>(p1);
|
||||
}
|
||||
|
||||
void deallocate(pointer memory, size_type) {
|
||||
void* p1 = memory;
|
||||
::operator delete(p1);
|
||||
}
|
||||
|
||||
void construct(pointer memory, const Y& value) {
|
||||
void* p1 = memory;
|
||||
::new(p1) Y(value);
|
||||
}
|
||||
|
||||
void destroy(pointer memory) {
|
||||
memory->~Y();
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator==(const make_array_helper<T[N], U>&) const {
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename U>
|
||||
bool operator!=(const make_array_helper<T[N], U>& other) const {
|
||||
return !(*this == other);
|
||||
}
|
||||
|
||||
private:
|
||||
enum {
|
||||
N1 = N * sizeof(T)
|
||||
};
|
||||
|
||||
T** data;
|
||||
};
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -15,12 +15,15 @@ namespace boost {
|
||||
namespace detail {
|
||||
template<typename T>
|
||||
struct sp_if_array;
|
||||
|
||||
template<typename T>
|
||||
struct sp_if_array<T[]> {
|
||||
typedef boost::shared_ptr<T[]> type;
|
||||
};
|
||||
|
||||
template<typename T>
|
||||
struct sp_if_size_array;
|
||||
|
||||
template<typename T, std::size_t N>
|
||||
struct sp_if_size_array<T[N]> {
|
||||
typedef boost::shared_ptr<T[N]> type;
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -14,9 +14,6 @@
|
||||
#include <boost/smart_ptr/detail/array_traits.hpp>
|
||||
#include <boost/smart_ptr/detail/make_array_helper.hpp>
|
||||
#include <boost/smart_ptr/detail/sp_if_array.hpp>
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
#include <initializer_list>
|
||||
#endif
|
||||
|
||||
namespace boost {
|
||||
template<typename T>
|
||||
@ -36,67 +33,27 @@ namespace boost {
|
||||
d2->init(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename T, typename... Args>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
make_shared(std::size_t size, Args&&... args) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
std::size_t n1 = size * boost::detail::array_total<T1>::size;
|
||||
boost::detail::make_array_helper<T2[]> a1(n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<Args>(args)...);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
template<typename T, typename... Args>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
make_shared(Args&&... args) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
boost::detail::make_array_helper<T2[N]> a1(&p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<Args>(args)...);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
make_shared(const T& list) {
|
||||
make_shared() {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
typedef const T2 T3;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
T3* p3 = 0;
|
||||
boost::detail::make_array_helper<T2[N]> a1(&p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init_list(p2, p3);
|
||||
d2->init(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
make_shared(std::size_t size,
|
||||
@ -115,12 +72,13 @@ namespace boost {
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p3 = reinterpret_cast<T3*>(&list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->template init_list<M>(p2, p3);
|
||||
d2->template init<M>(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
make_shared(const typename boost::detail::array_inner<T>::type& list) {
|
||||
@ -138,74 +96,13 @@ namespace boost {
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list);
|
||||
p3 = reinterpret_cast<T3*>(&list);
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->template init_list<M>(p2, p3);
|
||||
d2->template init<M>(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
make_shared(std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
typedef const T2 T3;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
T3* p3 = 0;
|
||||
std::size_t n1 = list.size() * boost::detail::array_total<T1>::size;
|
||||
boost::detail::make_array_helper<T2[]> a1(n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p3 = reinterpret_cast<T3*>(list.begin());
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init_list(p2, p3);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
make_shared(std::size_t size,
|
||||
typename boost::detail::array_base<T>::type&& value) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
std::size_t n1 = size * boost::detail::array_total<T1>::size;
|
||||
boost::detail::make_array_helper<T2[]> a1(n1, &p2);
|
||||
boost::detail::array_deleter<T2[]> d1(n1);
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<T2>(value));
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
make_shared(typename boost::detail::array_base<T>::type&& value) {
|
||||
typedef typename boost::detail::array_inner<T>::type T1;
|
||||
typedef typename boost::detail::array_base<T1>::type T2;
|
||||
enum {
|
||||
N = boost::detail::array_total<T>::size
|
||||
};
|
||||
T1* p1 = 0;
|
||||
T2* p2 = 0;
|
||||
boost::detail::make_array_helper<T2[N]> a1(&p2);
|
||||
boost::detail::array_deleter<T2[N]> d1;
|
||||
boost::shared_ptr<T> s1(p1, d1, a1);
|
||||
typedef boost::detail::array_deleter<T2[N]>* D2;
|
||||
p1 = reinterpret_cast<T1*>(p2);
|
||||
D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
|
||||
d2->init(p2, boost::detail::sp_forward<T2>(value));
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_array<T>::type
|
||||
make_shared_noinit(std::size_t size) {
|
||||
@ -223,6 +120,7 @@ namespace boost {
|
||||
d2->noinit(p2);
|
||||
return boost::shared_ptr<T>(s1, p1);
|
||||
}
|
||||
|
||||
template<typename T>
|
||||
inline typename boost::detail::sp_if_size_array<T>::type
|
||||
make_shared_noinit() {
|
||||
|
||||
@ -137,22 +137,16 @@ import testing ;
|
||||
[ compile-fail array_fail_array_access.cpp ]
|
||||
|
||||
[ run make_shared_array_test.cpp ]
|
||||
[ run make_shared_arrays_test.cpp ]
|
||||
[ run make_shared_array_create_test.cpp ]
|
||||
[ run make_shared_array_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run make_shared_arrays_create_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run make_shared_arrays_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run make_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run make_shared_array_throws_test.cpp ]
|
||||
[ run make_shared_array_esft_test.cpp ]
|
||||
[ run make_shared_array_args_test.cpp ]
|
||||
[ run make_shared_array_noinit_test.cpp ]
|
||||
[ run make_shared_array_value_test.cpp ]
|
||||
[ run allocate_shared_array_test.cpp ]
|
||||
[ run allocate_shared_arrays_test.cpp ]
|
||||
[ run allocate_shared_array_create_test.cpp ]
|
||||
[ run allocate_shared_array_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run allocate_shared_arrays_create_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run allocate_shared_arrays_init_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run allocate_shared_arrays_test.cpp : : : <toolset>gcc-4.6.3_0x:<cxxflags>-fno-deduce-init-list ]
|
||||
[ run allocate_shared_array_throws_test.cpp ]
|
||||
[ run allocate_shared_array_esft_test.cpp ]
|
||||
[ run allocate_shared_array_args_test.cpp ]
|
||||
[ run allocate_shared_array_noinit_test.cpp ]
|
||||
[ run allocate_shared_array_value_test.cpp ]
|
||||
;
|
||||
}
|
||||
|
||||
@ -1,173 +0,0 @@
|
||||
// allocate_shared_array_args_test.cpp
|
||||
//
|
||||
// Copyright 2007-2009, 2012 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <memory>
|
||||
#include <cstddef>
|
||||
|
||||
class X
|
||||
{
|
||||
private:
|
||||
|
||||
X( X const & );
|
||||
X & operator=( X const & );
|
||||
|
||||
void * operator new[]( std::size_t n );
|
||||
void operator delete[]( void * p );
|
||||
|
||||
public:
|
||||
|
||||
static int instances;
|
||||
|
||||
int v;
|
||||
|
||||
explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
|
||||
{
|
||||
++instances;
|
||||
}
|
||||
|
||||
~X()
|
||||
{
|
||||
--instances;
|
||||
}
|
||||
};
|
||||
|
||||
int X::instances = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 0 );
|
||||
BOOST_TEST( px[1].v == 0 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1 );
|
||||
BOOST_TEST( px[1].v == 1 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2 );
|
||||
BOOST_TEST( px[1].v == 1+2 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3 );
|
||||
BOOST_TEST( px[1].v == 1+2+3 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7, 8 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::allocate_shared< X[] >( std::allocator<X>(), 2, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8+9 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,114 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static int instances;
|
||||
explicit type(int a=0, int b=0, int c=0, int d=0, int e=0, int f=0, int g=0, int h=0, int i=0)
|
||||
: a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i) {
|
||||
instances++;
|
||||
}
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
const int a;
|
||||
const int b;
|
||||
const int c;
|
||||
const int d;
|
||||
const int e;
|
||||
const int f;
|
||||
const int g;
|
||||
const int h;
|
||||
const int i;
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
BOOST_TEST(type::instances == 2);
|
||||
BOOST_TEST(a1[0].a == 1);
|
||||
BOOST_TEST(a1[0].d == 4);
|
||||
BOOST_TEST(a1[1].f == 6);
|
||||
BOOST_TEST(a1[1].i == 9);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2]> a1 = boost::allocate_shared<type[2]>(std::allocator<type>(), 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
BOOST_TEST(type::instances == 2);
|
||||
BOOST_TEST(a1[0].a == 1);
|
||||
BOOST_TEST(a1[0].d == 4);
|
||||
BOOST_TEST(a1[1].f == 6);
|
||||
BOOST_TEST(a1[1].i == 9);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5, 6, 7);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
BOOST_TEST(a1[0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1].d == 4);
|
||||
BOOST_TEST(a1[1][0].f == 6);
|
||||
BOOST_TEST(a1[1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(std::allocator<type>(), 1, 2, 3, 4, 5, 6, 7);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
BOOST_TEST(a1[0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1].d == 4);
|
||||
BOOST_TEST(a1[1][0].f == 6);
|
||||
BOOST_TEST(a1[1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2, 1, 2, 3, 4, 5);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
BOOST_TEST(a1[0][0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1][0].c == 3);
|
||||
BOOST_TEST(a1[1][0][1].e == 5);
|
||||
BOOST_TEST(a1[1][1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared<type[2][2][2]>(std::allocator<type>(), 1, 2, 3, 4, 5);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
BOOST_TEST(a1[0][0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1][0].c == 3);
|
||||
BOOST_TEST(a1[1][0][1].e == 5);
|
||||
BOOST_TEST(a1[1][1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2][2]> a1 = boost::allocate_shared<type[][2][2][2]>(std::allocator<type>(), 2, 1, 2, 3);
|
||||
BOOST_TEST(type::instances == 16);
|
||||
BOOST_TEST(a1[0][0][0][1].a == 1);
|
||||
BOOST_TEST(a1[0][0][1][0].c == 3);
|
||||
BOOST_TEST(a1[0][1][0][0].f == 0);
|
||||
BOOST_TEST(a1[1][0][0][0].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2][2]> a1 = boost::allocate_shared<type[2][2][2][2]>(std::allocator<type>(), 1, 2, 3);
|
||||
BOOST_TEST(type::instances == 16);
|
||||
BOOST_TEST(a1[0][0][0][1].a == 1);
|
||||
BOOST_TEST(a1[0][0][1][0].c == 3);
|
||||
BOOST_TEST(a1[0][1][0][0].f == 0);
|
||||
BOOST_TEST(a1[1][0][0][0].i == 0);
|
||||
}
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -14,12 +14,15 @@ class type
|
||||
: public boost::enable_shared_from_this<type> {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
@ -38,6 +41,7 @@ int main() {
|
||||
BOOST_TEST(type::instances == 3);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
|
||||
@ -48,5 +52,6 @@ int main() {
|
||||
BOOST_TEST(type::instances == 3);
|
||||
}
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,84 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
type(int value)
|
||||
: value(value) {
|
||||
}
|
||||
const int value;
|
||||
private:
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[4]> a1 = boost::allocate_shared<type[4]>(std::allocator<type>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const type[4]> a1 = boost::allocate_shared<const type[4]>(std::allocator<type>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), { 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
181
test/allocate_shared_array_noinit_test.cpp
Normal file
181
test/allocate_shared_array_noinit_test.cpp
Normal file
@ -0,0 +1,181 @@
|
||||
/*
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
#include <boost/smart_ptr/weak_ptr.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::allocate_shared_noinit<int[]>(std::allocator<int>(), 3);
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::allocate_shared_noinit<int[][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared_noinit<int[2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared_noinit<const int[][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared_noinit<const int[2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::allocate_shared_noinit<type[3]>(std::allocator<type>());
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared_noinit<type[2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::allocate_shared_noinit<const type[3]>(std::allocator<type>());
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared_noinit<const type[][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared_noinit<const type[2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,11 +1,11 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
#include <boost/smart_ptr/weak_ptr.hpp>
|
||||
@ -14,17 +14,18 @@
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
explicit type(int = 0, int = 0)
|
||||
: member() {
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
double member;
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
@ -40,6 +41,38 @@ int main() {
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::allocate_shared<int[3]>(std::allocator<int>());
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 3);
|
||||
const int* a2 = a1.get();
|
||||
@ -50,6 +83,38 @@ int main() {
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::allocate_shared<const int[3]>(std::allocator<int>());
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3);
|
||||
@ -62,6 +127,40 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(std::allocator<type>());
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::allocate_shared<type[][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::allocate_shared<type[2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3);
|
||||
@ -73,109 +172,10 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 3, 1, 5);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::allocate_shared<type[3]>(std::allocator<type>(), 1, 5);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::allocate_shared<const type[]>(std::allocator<type>(), 3, 1, 5);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(std::allocator<type>(), 1, 5);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::allocate_shared_noinit<int[]>(std::allocator<int>(), 3);
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::allocate_shared_noinit<type[3]>(std::allocator<type>());
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
|
||||
boost::shared_ptr<const type[3]> a1 = boost::allocate_shared<const type[3]>(std::allocator<type>());
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
@ -184,16 +184,26 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::allocate_shared_noinit<const type[3]>(std::allocator<type>());
|
||||
const type* a2 = a1.get();
|
||||
boost::shared_ptr<const type[][2]> a1 = boost::allocate_shared<const type[][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2]> a1 = boost::allocate_shared<const type[2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -12,15 +12,18 @@
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
if (instances == 5) {
|
||||
throw true;
|
||||
}
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
@ -36,6 +39,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared<type[][2]>(std::allocator<type>(), 3);
|
||||
@ -43,7 +47,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared<type[6]>(std::allocator<type>());
|
||||
@ -51,6 +55,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared<type[3][2]>(std::allocator<type>());
|
||||
@ -58,7 +63,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
|
||||
@ -66,6 +71,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
|
||||
@ -73,5 +79,24 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared_noinit<type[6]>(std::allocator<type>());
|
||||
BOOST_ERROR("allocate_shared_noinit did not throw");
|
||||
}
|
||||
catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::allocate_shared_noinit<type[3][2]>(std::allocator<type>());
|
||||
BOOST_ERROR("allocate_shared_noinit did not throw");
|
||||
}
|
||||
catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
46
test/allocate_shared_array_value_test.cpp
Normal file
46
test/allocate_shared_array_value_test.cpp
Normal file
@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
int main() {
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), 4, 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::allocate_shared<const int[]>(std::allocator<int>(), 4, 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[4]> a1 = boost::allocate_shared<const int[4]>(std::allocator<int>(), 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,94 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
type(int x, int y)
|
||||
: x(x), y(y) {
|
||||
}
|
||||
const int x;
|
||||
const int y;
|
||||
private:
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::allocate_shared<int[4]>(std::allocator<int>(), {0, 1, 2, 3});
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 2);
|
||||
BOOST_TEST(a1[1][1] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2, {0, 1});
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared<int[][2][2]>(std::allocator<int>(), 2, { {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0][0] == 0);
|
||||
BOOST_TEST(a1[0][0][1] == 1);
|
||||
BOOST_TEST(a1[1][1][0] == 2);
|
||||
BOOST_TEST(a1[1][1][1] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), {0, 1});
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2][2]> a1 = boost::allocate_shared<int[2][2][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0][0] == 0);
|
||||
BOOST_TEST(a1[0][0][1] == 1);
|
||||
BOOST_TEST(a1[1][1][0] == 2);
|
||||
BOOST_TEST(a1[1][1][1] == 3);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::allocate_shared<int[]>(std::allocator<int>(), {0, 1, 2, 3});
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::allocate_shared<type[]>(std::allocator<type>(), 4, {1, 2});
|
||||
BOOST_TEST(a1[0].x == 1);
|
||||
BOOST_TEST(a1[1].y == 2);
|
||||
BOOST_TEST(a1[2].x == 1);
|
||||
BOOST_TEST(a1[3].y == 2);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[4]> a1 = boost::allocate_shared<type[4]>(std::allocator<type>(), {1, 2});
|
||||
BOOST_TEST(a1[0].x == 1);
|
||||
BOOST_TEST(a1[1].y == 2);
|
||||
BOOST_TEST(a1[2].x == 1);
|
||||
BOOST_TEST(a1[3].y == 2);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), { {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 2);
|
||||
BOOST_TEST(a1[1][1] == 3);
|
||||
}
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -9,152 +9,40 @@
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/allocate_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
explicit type(int = 0, int = 0)
|
||||
: member() {
|
||||
instances++;
|
||||
}
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
double member;
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared<int[][2][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0][1] == 0);
|
||||
BOOST_TEST(a1[0][1][0] == 0);
|
||||
BOOST_TEST(a1[1][0][0] == 0);
|
||||
boost::shared_ptr<int[][2]> a1 = boost::allocate_shared<int[][2]>(std::allocator<int>(), 2, {0, 1});
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[][2][2]> a1 = boost::allocate_shared<const int[][2][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0][1] == 0);
|
||||
BOOST_TEST(a1[0][1][0] == 0);
|
||||
BOOST_TEST(a1[1][0][0] == 0);
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::allocate_shared<int[2][2]>(std::allocator<int>(), { 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::allocate_shared<const int[][2]>(std::allocator<int>(), 2, { 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared<const type[][2][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared<type[][2][2]>(std::allocator<type>(), 2, 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared<type[2][2][2]>(std::allocator<type>(), 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared<const type[][2][2]>(std::allocator<type>(), 2, 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2][2]> a1 = boost::allocate_shared<const type[2][2][2]>(std::allocator<type>(), 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::allocate_shared<const int[2][2]>(std::allocator<int>(), { 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared_noinit<int[][2][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2][2]> a1 = boost::allocate_shared_noinit<int[2][2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[][2][2]> a1 = boost::allocate_shared_noinit<const int[][2][2]>(std::allocator<int>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[2][2][2]> a1 = boost::allocate_shared_noinit<const int[2][2][2]>(std::allocator<int>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared_noinit<type[][2][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared_noinit<type[2][2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared_noinit<const type[][2][2]>(std::allocator<type>(), 2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2][2]> a1 = boost::allocate_shared_noinit<const type[2][2][2]>(std::allocator<type>());
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,172 +0,0 @@
|
||||
// make_shared_array_args_test.cpp
|
||||
//
|
||||
// Copyright 2007-2009, 2012 Peter Dimov
|
||||
//
|
||||
// Distributed under the Boost Software License, Version 1.0.
|
||||
// See accompanying file LICENSE_1_0.txt or copy at
|
||||
// http://www.boost.org/LICENSE_1_0.txt
|
||||
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/make_shared.hpp>
|
||||
#include <boost/shared_ptr.hpp>
|
||||
#include <cstddef>
|
||||
|
||||
class X
|
||||
{
|
||||
private:
|
||||
|
||||
X( X const & );
|
||||
X & operator=( X const & );
|
||||
|
||||
void * operator new[]( std::size_t n );
|
||||
void operator delete[]( void * p );
|
||||
|
||||
public:
|
||||
|
||||
static int instances;
|
||||
|
||||
int v;
|
||||
|
||||
explicit X( int a1 = 0, int a2 = 0, int a3 = 0, int a4 = 0, int a5 = 0, int a6 = 0, int a7 = 0, int a8 = 0, int a9 = 0 ): v( a1+a2+a3+a4+a5+a6+a7+a8+a9 )
|
||||
{
|
||||
++instances;
|
||||
}
|
||||
|
||||
~X()
|
||||
{
|
||||
--instances;
|
||||
}
|
||||
};
|
||||
|
||||
int X::instances = 0;
|
||||
|
||||
int main()
|
||||
{
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 0 );
|
||||
BOOST_TEST( px[1].v == 0 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
#if !defined( BOOST_NO_CXX11_VARIADIC_TEMPLATES ) && !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1 );
|
||||
BOOST_TEST( px[1].v == 1 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2 );
|
||||
BOOST_TEST( px[1].v == 1+2 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3 );
|
||||
BOOST_TEST( px[1].v == 1+2+3 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7, 8 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr< X[] > px = boost::make_shared< X[] >( 2, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
|
||||
|
||||
BOOST_TEST( X::instances == 2 );
|
||||
BOOST_TEST( px[0].v == 1+2+3+4+5+6+7+8+9 );
|
||||
BOOST_TEST( px[1].v == 1+2+3+4+5+6+7+8+9 );
|
||||
|
||||
px.reset();
|
||||
|
||||
BOOST_TEST( X::instances == 0 );
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,114 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static int instances;
|
||||
explicit type(int a=0, int b=0, int c=0, int d=0, int e=0, int f=0, int g=0, int h=0, int i=0)
|
||||
: a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i) {
|
||||
instances++;
|
||||
}
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
const int a;
|
||||
const int b;
|
||||
const int c;
|
||||
const int d;
|
||||
const int e;
|
||||
const int f;
|
||||
const int g;
|
||||
const int h;
|
||||
const int i;
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(2, 1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
BOOST_TEST(type::instances == 2);
|
||||
BOOST_TEST(a1[0].a == 1);
|
||||
BOOST_TEST(a1[0].d == 4);
|
||||
BOOST_TEST(a1[1].f == 6);
|
||||
BOOST_TEST(a1[1].i == 9);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2]> a1 = boost::make_shared<type[2]>(1, 2, 3, 4, 5, 6, 7, 8, 9);
|
||||
BOOST_TEST(type::instances == 2);
|
||||
BOOST_TEST(a1[0].a == 1);
|
||||
BOOST_TEST(a1[0].d == 4);
|
||||
BOOST_TEST(a1[1].f == 6);
|
||||
BOOST_TEST(a1[1].i == 9);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::make_shared<type[][2]>(2, 1, 2, 3, 4, 5, 6, 7);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
BOOST_TEST(a1[0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1].d == 4);
|
||||
BOOST_TEST(a1[1][0].f == 6);
|
||||
BOOST_TEST(a1[1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::make_shared<type[2][2]>(1, 2, 3, 4, 5, 6, 7);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
BOOST_TEST(a1[0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1].d == 4);
|
||||
BOOST_TEST(a1[1][0].f == 6);
|
||||
BOOST_TEST(a1[1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2, 1, 2, 3, 4, 5);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
BOOST_TEST(a1[0][0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1][0].c == 3);
|
||||
BOOST_TEST(a1[1][0][1].e == 5);
|
||||
BOOST_TEST(a1[1][1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared<type[2][2][2]>(1, 2, 3, 4, 5);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
BOOST_TEST(a1[0][0][0].a == 1);
|
||||
BOOST_TEST(a1[0][1][0].c == 3);
|
||||
BOOST_TEST(a1[1][0][1].e == 5);
|
||||
BOOST_TEST(a1[1][1][1].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2][2]> a1 = boost::make_shared<type[][2][2][2]>(2, 1, 2, 3);
|
||||
BOOST_TEST(type::instances == 16);
|
||||
BOOST_TEST(a1[0][0][0][1].a == 1);
|
||||
BOOST_TEST(a1[0][0][1][0].c == 3);
|
||||
BOOST_TEST(a1[0][1][0][0].f == 0);
|
||||
BOOST_TEST(a1[1][0][0][0].i == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2][2]> a1 = boost::make_shared<type[2][2][2][2]>(1, 2, 3);
|
||||
BOOST_TEST(type::instances == 16);
|
||||
BOOST_TEST(a1[0][0][0][1].a == 1);
|
||||
BOOST_TEST(a1[0][0][1][0].c == 3);
|
||||
BOOST_TEST(a1[0][1][0][0].f == 0);
|
||||
BOOST_TEST(a1[1][0][0][0].i == 0);
|
||||
}
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -14,12 +14,15 @@ class type
|
||||
: public boost::enable_shared_from_this<type> {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
@ -38,6 +41,7 @@ int main() {
|
||||
BOOST_TEST(type::instances == 3);
|
||||
}
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
|
||||
@ -48,5 +52,6 @@ int main() {
|
||||
BOOST_TEST(type::instances == 3);
|
||||
}
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,84 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
type(int value)
|
||||
: value(value) {
|
||||
}
|
||||
const int value;
|
||||
private:
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[4]> a1 = boost::make_shared<type[4]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const type[4]> a1 = boost::make_shared<const type[4]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>({ 0, 1, 2, 3 });
|
||||
BOOST_TEST(a1[0].value == 0);
|
||||
BOOST_TEST(a1[1].value == 1);
|
||||
BOOST_TEST(a1[2].value == 2);
|
||||
BOOST_TEST(a1[3].value == 3);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
181
test/make_shared_array_noinit_test.cpp
Normal file
181
test/make_shared_array_noinit_test.cpp
Normal file
@ -0,0 +1,181 @@
|
||||
/*
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
#include <boost/smart_ptr/weak_ptr.hpp>
|
||||
#include <boost/type_traits/alignment_of.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::make_shared_noinit<int[]>(3);
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::make_shared_noinit<int[3]>();
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::make_shared_noinit<int[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::make_shared_noinit<int[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::make_shared_noinit<const int[]>(3);
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::make_shared_noinit<const int[3]>();
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::make_shared_noinit<const int[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::make_shared_noinit<const int[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::make_shared_noinit<type[3]>();
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::make_shared_noinit<type[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::make_shared_noinit<type[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::make_shared_noinit<const type[]>(3);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::make_shared_noinit<const type[3]>();
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2]> a1 = boost::make_shared_noinit<const type[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2]> a1 = boost::make_shared_noinit<const type[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -14,17 +14,18 @@
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
explicit type(int = 0, int = 0)
|
||||
: member() {
|
||||
|
||||
explicit type() {
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
double member;
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
@ -40,6 +41,38 @@ int main() {
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::make_shared<int[3]>();
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(3);
|
||||
const int* a2 = a1.get();
|
||||
@ -50,6 +83,38 @@ int main() {
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::make_shared<const int[3]>();
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 0);
|
||||
BOOST_TEST(a1[2] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 0);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3);
|
||||
@ -62,6 +127,40 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::make_shared<type[3]>();
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2]> a1 = boost::make_shared<type[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2]> a1 = boost::make_shared<type[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3);
|
||||
@ -73,109 +172,10 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(3, 1, 5);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::make_shared<type[3]>(1, 5);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::make_shared<const type[]>(3, 1, 5);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::make_shared<const type[3]>(1, 5);
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::make_shared_noinit<int[]>(3);
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[3]> a1 = boost::make_shared_noinit<int[3]>();
|
||||
int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::make_shared_noinit<const int[]>(3);
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[3]> a1 = boost::make_shared_noinit<const int[3]>();
|
||||
const int* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared_noinit<type[]>(3);
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[3]> a1 = boost::make_shared_noinit<type[3]>();
|
||||
type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
boost::weak_ptr<type[3]> w1 = a1;
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[]> a1 = boost::make_shared_noinit<const type[]>(3);
|
||||
boost::shared_ptr<const type[3]> a1 = boost::make_shared<const type[3]>();
|
||||
const type* a2 = a1.get();
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
@ -184,16 +184,26 @@ int main() {
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[3]> a1 = boost::make_shared_noinit<const type[3]>();
|
||||
const type* a2 = a1.get();
|
||||
boost::shared_ptr<const type[][2]> a1 = boost::make_shared<const type[][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a2 != 0);
|
||||
BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
|
||||
BOOST_TEST(type::instances == 3);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2]> a1 = boost::make_shared<const type[2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 4);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -12,15 +12,18 @@
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
|
||||
explicit type() {
|
||||
if (instances == 5) {
|
||||
throw true;
|
||||
}
|
||||
instances++;
|
||||
}
|
||||
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
@ -36,6 +39,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared<type[][2]>(3);
|
||||
@ -43,7 +47,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared<type[6]>();
|
||||
@ -51,6 +55,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared<type[3][2]>();
|
||||
@ -58,7 +63,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared_noinit<type[]>(6);
|
||||
@ -66,6 +71,7 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared_noinit<type[][2]>(3);
|
||||
@ -73,5 +79,24 @@ int main() {
|
||||
} catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared_noinit<type[6]>();
|
||||
BOOST_ERROR("make_shared_noinit did not throw");
|
||||
}
|
||||
catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
BOOST_TEST(type::instances == 0);
|
||||
try {
|
||||
boost::make_shared_noinit<type[3][2]>();
|
||||
BOOST_ERROR("make_shared_noinit did not throw");
|
||||
}
|
||||
catch (...) {
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
46
test/make_shared_array_value_test.cpp
Normal file
46
test/make_shared_array_value_test.cpp
Normal file
@ -0,0 +1,46 @@
|
||||
/*
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
int main() {
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>(4, 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>(1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[]> a1 = boost::make_shared<const int[]>(4, 1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
{
|
||||
boost::shared_ptr<const int[4]> a1 = boost::make_shared<const int[4]>(1);
|
||||
BOOST_TEST(a1[0] == 1);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 1);
|
||||
BOOST_TEST(a1[3] == 1);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,94 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
type(int x, int y)
|
||||
: x(x), y(y) {
|
||||
}
|
||||
const int x;
|
||||
const int y;
|
||||
private:
|
||||
type& operator=(const type&);
|
||||
};
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[4]> a1 = boost::make_shared<int[4]>({0, 1, 2, 3});
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 2);
|
||||
BOOST_TEST(a1[1][1] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2, {0, 1});
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::make_shared<int[][2][2]>(2, { {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0][0] == 0);
|
||||
BOOST_TEST(a1[0][0][1] == 1);
|
||||
BOOST_TEST(a1[1][1][0] == 2);
|
||||
BOOST_TEST(a1[1][1][1] == 3);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2][2]> a1 = boost::make_shared<int[2][2][2]>({ {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0][0] == 0);
|
||||
BOOST_TEST(a1[0][0][1] == 1);
|
||||
BOOST_TEST(a1[1][1][0] == 2);
|
||||
BOOST_TEST(a1[1][1][1] == 3);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[]> a1 = boost::make_shared<int[]>({0, 1, 2, 3});
|
||||
BOOST_TEST(a1[0] == 0);
|
||||
BOOST_TEST(a1[1] == 1);
|
||||
BOOST_TEST(a1[2] == 2);
|
||||
BOOST_TEST(a1[3] == 3);
|
||||
}
|
||||
#endif
|
||||
#if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
{
|
||||
boost::shared_ptr<type[]> a1 = boost::make_shared<type[]>(4, {1, 2});
|
||||
BOOST_TEST(a1[0].x == 1);
|
||||
BOOST_TEST(a1[1].y == 2);
|
||||
BOOST_TEST(a1[2].x == 1);
|
||||
BOOST_TEST(a1[3].y == 2);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<type[4]> a1 = boost::make_shared<type[4]>({1, 2});
|
||||
BOOST_TEST(a1[0].x == 1);
|
||||
BOOST_TEST(a1[1].y == 2);
|
||||
BOOST_TEST(a1[2].x == 1);
|
||||
BOOST_TEST(a1[3].y == 2);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,23 +0,0 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
* Version 1.0. (See accompanying file LICENSE_1_0.txt
|
||||
* or copy at http://boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX) && !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
|
||||
{
|
||||
boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>({ {0, 1}, {2, 3} });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 2);
|
||||
BOOST_TEST(a1[1][1] == 3);
|
||||
}
|
||||
#endif
|
||||
return boost::report_errors();
|
||||
}
|
||||
@ -1,5 +1,5 @@
|
||||
/*
|
||||
* Copyright (c) 2012 Glen Joseph Fernandes
|
||||
* Copyright (c) 2012-2014 Glen Joseph Fernandes
|
||||
* glenfe at live dot com
|
||||
*
|
||||
* Distributed under the Boost Software License,
|
||||
@ -9,152 +9,40 @@
|
||||
#include <boost/detail/lightweight_test.hpp>
|
||||
#include <boost/smart_ptr/make_shared_array.hpp>
|
||||
|
||||
class type {
|
||||
public:
|
||||
static unsigned int instances;
|
||||
explicit type(int = 0, int = 0)
|
||||
: member() {
|
||||
instances++;
|
||||
}
|
||||
~type() {
|
||||
instances--;
|
||||
}
|
||||
private:
|
||||
type(const type&);
|
||||
type& operator=(const type&);
|
||||
double member;
|
||||
};
|
||||
|
||||
unsigned int type::instances = 0;
|
||||
|
||||
int main() {
|
||||
#if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::make_shared<int[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0][1] == 0);
|
||||
BOOST_TEST(a1[0][1][0] == 0);
|
||||
BOOST_TEST(a1[1][0][0] == 0);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[][2][2]> a1 = boost::make_shared<const int[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(a1[0][0][1] == 0);
|
||||
BOOST_TEST(a1[0][1][0] == 0);
|
||||
BOOST_TEST(a1[1][0][0] == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared<const type[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<int[][2]> a1 = boost::make_shared<int[][2]>(2, {0, 1});
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
#if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) && !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
|
||||
BOOST_TEST(type::instances == 0);
|
||||
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::make_shared<type[][2][2]>(2, 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<int[2][2]> a1 = boost::make_shared<int[2][2]>({ 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared<type[2][2][2]>(1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<const int[][2]> a1 = boost::make_shared<const int[][2]>(2, { 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared<const type[][2][2]>(2, 1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2][2]> a1 = boost::make_shared<const type[2][2][2]>(1, 5);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
boost::shared_ptr<const int[2][2]> a1 = boost::make_shared<const int[2][2]>({ 0, 1 });
|
||||
BOOST_TEST(a1[0][0] == 0);
|
||||
BOOST_TEST(a1[0][1] == 1);
|
||||
BOOST_TEST(a1[1][0] == 0);
|
||||
BOOST_TEST(a1[1][1] == 1);
|
||||
}
|
||||
#endif
|
||||
{
|
||||
boost::shared_ptr<int[][2][2]> a1 = boost::make_shared_noinit<int[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<int[2][2][2]> a1 = boost::make_shared_noinit<int[2][2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[][2][2]> a1 = boost::make_shared_noinit<const int[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
{
|
||||
boost::shared_ptr<const int[2][2][2]> a1 = boost::make_shared_noinit<const int[2][2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[][2][2]> a1 = boost::make_shared_noinit<type[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<type[2][2][2]> a1 = boost::make_shared_noinit<type[2][2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[][2][2]> a1 = boost::make_shared_noinit<const type[][2][2]>(2);
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
BOOST_TEST(type::instances == 0);
|
||||
{
|
||||
boost::shared_ptr<const type[2][2][2]> a1 = boost::make_shared_noinit<const type[2][2][2]>();
|
||||
BOOST_TEST(a1.get() != 0);
|
||||
BOOST_TEST(a1.use_count() == 1);
|
||||
BOOST_TEST(type::instances == 8);
|
||||
a1.reset();
|
||||
BOOST_TEST(type::instances == 0);
|
||||
}
|
||||
|
||||
return boost::report_errors();
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user