Subject: [Boost-commit] svn:boost r61175 - trunk/libs/config/test
From: nielsdekker_at_[hidden]
Date: 2010-04-10 06:28:40
Author: niels_dekker
Date: 2010-04-10 06:28:40 EDT (Sat, 10 Apr 2010)
New Revision: 61175
URL: http://svn.boost.org/trac/boost/changeset/61175
Log:
Added more value-initialization tests. Added more comment. Printed revision number. Avoided CodeGear 2010 warning W8070, "Function should return a value".
Text files modified:
trunk/libs/config/test/boost_no_com_value_init.ipp | 184 ++++++++++++++++++++++++++++++++++++---
1 files changed, 167 insertions(+), 17 deletions(-)
Modified: trunk/libs/config/test/boost_no_com_value_init.ipp
==============================================================================
--- trunk/libs/config/test/boost_no_com_value_init.ipp (original)
+++ trunk/libs/config/test/boost_no_com_value_init.ipp 2010-04-10 06:28:40 EDT (Sat, 10 Apr 2010)
@@ -47,7 +47,21 @@
arg.p == 0;
}
+ struct derived_pod_struct: pod_struct
+ {
+ int derived_data;
+ };
+
+ bool is_zero_initialized(const derived_pod_struct& arg)
+ {
+ const pod_struct& base_subobject = arg;
+ return arg.derived_data == 0 && is_zero_initialized(base_subobject);
+ }
+
+
// A class that holds a "magic" enum value.
+ // Note: This is not a POD class, because it has a user-defined
+ // default constructor.
class enum_holder
{
enum_type m_enum;
@@ -66,6 +80,64 @@
};
+ // An aggregate struct of a non-POD class and an int.
+ struct enum_holder_and_int
+ {
+ enum_holder e;
+ int i;
+ };
+
+ bool is_value_initialized(const enum_holder_and_int& arg)
+ {
+ return arg.e.is_default() && arg.i == 0;
+ }
+
+
+ // An class that has a private and a protected int data member.
+ class private_and_protected_int
+ {
+ private:
+ int private_int;
+ protected:
+ int protected_int;
+ public:
+ bool is_value_initialized() const
+ {
+ return private_int == 0 && protected_int == 0;
+ }
+ };
+
+
+ class user_defined_destructor_holder
+ {
+ public:
+ int i;
+ ~user_defined_destructor_holder()
+ {
+ }
+ };
+
+ bool is_value_initialized(const user_defined_destructor_holder& arg)
+ {
+ return arg.i == 0;
+ }
+
+
+ class virtual_destructor_holder
+ {
+ public:
+ int i;
+ virtual ~virtual_destructor_holder()
+ {
+ }
+ };
+
+ bool is_value_initialized(const virtual_destructor_holder& arg)
+ {
+ return arg.i == 0;
+ }
+
+
// A class that is not a POD type.
class non_pod_class
{
@@ -83,6 +155,7 @@
virtual ~non_pod_class() {}
};
+
// The first argument (is_value_initializated) tells whether value initialization
// has succeeded.
// The second argument tells what expression was evaluated.
@@ -98,26 +171,47 @@
#define IS_TRUE(value) is_true(value, #value)
#define IS_ZERO(value) is_true(value == 0, #value " == 0")
- // The default constructor of this class initializes each of its
- // data members by means of an empty set of parentheses, and checks
- // whether each of them is value-initialized.
+ // value_initializer initializes each of its data members by means
+ // of an empty set of parentheses, and allows checking whether
+ // each of them is indeed value-initialized, as specified by
+ // the C++ Standard ([dcl.init]).
class value_initializer
{
private:
enum_holder m_enum_holder;
+ enum_holder m_enum_holder_array[2];
enum_type m_enum;
- char m_char;
- unsigned char m_unsigned_char;
+ enum_type m_enum_array[2];
+ char m_char;
+ char m_char_array[2];
+ unsigned char m_unsigned_char;
+ unsigned char m_unsigned_char_array[2];
short m_short;
+ short m_short_array[2];
int m_int;
+ int m_int_array[2];
unsigned m_unsigned;
+ unsigned m_unsigned_array[2];
long m_long;
- float m_float;
- double m_double;
+ long m_long_array[2];
+ float m_float;
+ float m_float_array[2];
+ double m_double;
+ double m_double_array[2];
void* m_ptr;
- int m_int_array[2];
+ void* m_ptr_array[2];
pod_struct m_pod;
pod_struct m_pod_array[2];
+ derived_pod_struct m_derived_pod;
+ derived_pod_struct m_derived_pod_array[2];
+ enum_holder_and_int m_enum_holder_and_int;
+ enum_holder_and_int m_enum_holder_and_int_array[2];
+ private_and_protected_int m_private_and_protected_int;
+ private_and_protected_int m_private_and_protected_int_array[2];
+ user_defined_destructor_holder m_user_defined_destructor_holder;
+ user_defined_destructor_holder m_user_defined_destructor_holder_array[2];
+ virtual_destructor_holder m_virtual_destructor_holder;
+ virtual_destructor_holder m_virtual_destructor_holder_array[2];
non_pod_class m_non_pod;
non_pod_class m_non_pod_array[2];
@@ -125,19 +219,39 @@
value_initializer()
:
m_enum_holder(),
+ m_enum_holder_array(),
m_enum(),
+ m_enum_array(),
m_char(),
+ m_char_array(),
m_unsigned_char(),
+ m_unsigned_char_array(),
m_short(),
+ m_short_array(),
m_int(),
+ m_int_array(),
m_unsigned(),
+ m_unsigned_array(),
m_long(),
+ m_long_array(),
m_float(),
+ m_float_array(),
m_double(),
+ m_double_array(),
m_ptr(),
- m_int_array(),
+ m_ptr_array(),
m_pod(),
m_pod_array(),
+ m_derived_pod(),
+ m_derived_pod_array(),
+ m_enum_holder_and_int(),
+ m_enum_holder_and_int_array(),
+ m_private_and_protected_int(),
+ m_private_and_protected_int_array(),
+ m_user_defined_destructor_holder(),
+ m_user_defined_destructor_holder_array(),
+ m_virtual_destructor_holder(),
+ m_virtual_destructor_holder_array(),
m_non_pod(),
m_non_pod_array()
{
@@ -146,30 +260,66 @@
// Returns the number of failures.
unsigned check() const
{
- return
+ const unsigned num_failures =
(IS_TRUE( m_enum_holder.is_default() ) ? 0 : 1) +
+ (IS_TRUE( m_enum_holder_array[0].is_default() ) ? 0 : 1) +
+ (IS_TRUE( m_enum_holder_array[1].is_default() ) ? 0 : 1) +
(IS_ZERO(m_enum) ? 0 : 1) +
+ (IS_ZERO(m_enum_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_enum_array[1]) ? 0 : 1) +
(IS_ZERO(m_char) ? 0 : 1) +
+ (IS_ZERO(m_char_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_char_array[1]) ? 0 : 1) +
(IS_ZERO(m_unsigned_char) ? 0 : 1) +
+ (IS_ZERO(m_unsigned_char_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_unsigned_char_array[1]) ? 0 : 1) +
(IS_ZERO(m_short) ? 0 : 1) +
+ (IS_ZERO(m_short_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_short_array[1]) ? 0 : 1) +
(IS_ZERO(m_int) ? 0 : 1) +
+ (IS_ZERO(m_int_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_int_array[1]) ? 0 : 1) +
(IS_ZERO(m_unsigned) ? 0 : 1) +
+ (IS_ZERO(m_unsigned_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_unsigned_array[1]) ? 0 : 1) +
(IS_ZERO(m_long) ? 0 : 1) +
+ (IS_ZERO(m_long_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_long_array[1]) ? 0 : 1) +
(IS_ZERO(m_float) ? 0 : 1) +
+ (IS_ZERO(m_float_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_float_array[1]) ? 0 : 1) +
(IS_ZERO(m_double) ? 0 : 1) +
+ (IS_ZERO(m_double_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_double_array[1]) ? 0 : 1) +
(IS_ZERO(m_ptr) ? 0 : 1) +
- (IS_ZERO(m_int_array[0]) ? 0 : 1) +
- (IS_ZERO(m_int_array[1]) ? 0 : 1) +
+ (IS_ZERO(m_ptr_array[0]) ? 0 : 1) +
+ (IS_ZERO(m_ptr_array[1]) ? 0 : 1) +
(IS_TRUE( is_zero_initialized(m_pod) ) ? 0 : 1) +
- (IS_TRUE( m_non_pod.is_value_initialized() ) ? 0 : 1) +
(IS_TRUE( is_zero_initialized(m_pod_array[0]) ) ? 0 : 1) +
(IS_TRUE( is_zero_initialized(m_pod_array[1]) ) ? 0 : 1) +
+ (IS_TRUE( is_zero_initialized(m_derived_pod) ) ? 0 : 1) +
+ (IS_TRUE( is_zero_initialized(m_derived_pod_array[0]) ) ? 0 : 1) +
+ (IS_TRUE( is_zero_initialized(m_derived_pod_array[1]) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_enum_holder_and_int) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_enum_holder_and_int_array[0]) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_enum_holder_and_int_array[1]) ) ? 0 : 1) +
+ (IS_TRUE( m_private_and_protected_int.is_value_initialized() ) ? 0 : 1) +
+ (IS_TRUE( m_private_and_protected_int_array[0].is_value_initialized() ) ? 0 : 1 ) +
+ (IS_TRUE( m_private_and_protected_int_array[1].is_value_initialized() ) ? 0 : 1 );
+ (IS_TRUE( is_value_initialized(m_user_defined_destructor_holder) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_user_defined_destructor_holder_array[0]) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_user_defined_destructor_holder_array[1]) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_virtual_destructor_holder) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_virtual_destructor_holder_array[0]) ) ? 0 : 1) +
+ (IS_TRUE( is_value_initialized(m_virtual_destructor_holder_array[1]) ) ? 0 : 1) +
+ (IS_TRUE( m_non_pod.is_value_initialized() ) ? 0 : 1) +
(IS_TRUE( m_non_pod_array[0].is_value_initialized() ) ? 0 : 1 ) +
(IS_TRUE( m_non_pod_array[1].is_value_initialized() ) ? 0 : 1 );
-
+ return num_failures;
}
};
+
int test()
{
// Check both value-initialization on the stack and on the heap:
@@ -180,11 +330,11 @@
if ( num_failures_on_stack > 0 || num_failures_on_heap > 0 )
{
std::cout << "Number of initialization failures on the stack: " << num_failures_on_stack
- << "\nNumber of initialization failures on the heap: " << num_failures_on_heap << std::endl;
-
+ << "\nNumber of initialization failures on the heap: " << num_failures_on_heap
+ << "\nDetected by boost_no_complete_value_initialization::test() revision 3."
+ << std::endl;
}
return static_cast<int>(num_failures_on_stack + num_failures_on_heap);
}
} // End of namespace.
-