From bb21fc7f1d27ee84c67c04c11b2c85a022a0d6a4 Mon Sep 17 00:00:00 2001
From: John Maddock <john@johnmaddock.co.uk>
Date: Sat, 20 Jan 2001 12:28:08 +0000
Subject: [PATCH] minor fixes for expected errors

[SVN r8654]
---
 .../boost/type_traits/type_traits_test.hpp    | 14 ++++++---
 development/object_type_traits_test.cpp       | 30 +++++++++----------
 2 files changed, 25 insertions(+), 19 deletions(-)

diff --git a/development/include/boost/type_traits/type_traits_test.hpp b/development/include/boost/type_traits/type_traits_test.hpp
index 93f599f..ea41177 100644
--- a/development/include/boost/type_traits/type_traits_test.hpp
+++ b/development/include/boost/type_traits/type_traits_test.hpp
@@ -51,16 +51,20 @@ int check_result(int argc, char** argv)
 template <bool>
 struct checker
 {
-   static void check(bool, bool, const char*){ ++test_count; }
+   static void check(bool, bool, const char*, bool){ ++test_count; }
 };
 
 template <>
 struct checker<false>
 {
-   static void check(bool o, bool n, const char* name)
+   static void check(bool o, bool n, const char* name, bool soft)
    {
       ++test_count;
       ++failures;
+      // if this is a soft test, then failure is expected,
+      // or may depend upon factors outside our control
+      // (like compiler options)...
+      if(soft)++expected_failures;
       std::cout << "checking value of " << name << "...failed" << std::endl;
       std::cout << "\tfound: " << n << " expected " << o << std::endl;
    }
@@ -103,7 +107,8 @@ struct type_checker<T,T>
 #endif
 
 
-#define value_test(v, x) checker<(v == x)>::check(v, x, #x);
+#define value_test(v, x) checker<(v == x)>::check(v, x, #x, false);
+#define soft_value_test(v, x) checker<(v == x)>::check(v, x, #x, true);
 
 #define value_fail(v, x) \
       ++test_count; \
@@ -128,7 +133,8 @@ struct test_align
       padded p;
       unsigned a = reinterpret_cast<char*>(&(p.t)) - reinterpret_cast<char*>(&p);
       ++test_count;
-      if(a != boost::alignment_of<T>::value)
+      // only fail if we do not have a multiple of the actual value:
+      if((a > ::boost::alignment_of<T>::value) || (a % ::boost::alignment_of<T>::value))
       {
          ++failures;
          std::cout << "checking value of " << typeid(boost::alignment_of<T>).name() << "...failed" << std::endl;
diff --git a/development/object_type_traits_test.cpp b/development/object_type_traits_test.cpp
index bcf3fb6..04b4f50 100644
--- a/development/object_type_traits_test.cpp
+++ b/development/object_type_traits_test.cpp
@@ -141,27 +141,27 @@ int main(int argc, char* argv[])
    value_test(false, boost::has_trivial_destructor<empty_UDT>::value)
    value_test(true, boost::has_trivial_destructor<enum_UDT>::value)
 
-   value_test(false, boost::is_empty<int>::value)
-   value_test(false, boost::is_empty<int*>::value)
-   value_test(false, boost::is_empty<int&>::value)
+   soft_value_test(false, boost::is_empty<int>::value)
+   soft_value_test(false, boost::is_empty<int*>::value)
+   soft_value_test(false, boost::is_empty<int&>::value)
 #if defined(__MWERKS__)
    // apparent compiler bug causes this to fail to compile:
    value_fail(false, boost::is_empty<int[2]>::value)
 #else
-   value_test(false, boost::is_empty<int[2]>::value)
+   soft_value_test(false, boost::is_empty<int[2]>::value)
 #endif
-   value_test(false, boost::is_empty<f1>::value)
-   value_test(false, boost::is_empty<mf1>::value)
-   value_test(false, boost::is_empty<UDT>::value)
-   value_test(true, boost::is_empty<empty_UDT>::value)
-   value_test(true, boost::is_empty<empty_POD_UDT>::value)
+   soft_value_test(false, boost::is_empty<f1>::value)
+   soft_value_test(false, boost::is_empty<mf1>::value)
+   soft_value_test(false, boost::is_empty<UDT>::value)
+   soft_value_test(true, boost::is_empty<empty_UDT>::value)
+   soft_value_test(true, boost::is_empty<empty_POD_UDT>::value)
    // this one will not compile on most compilers,
    // because we can't tell the difference between
    // unions and classes:
    value_fail(true, boost::is_empty<empty_union_UDT>::value)
-   value_test(false, boost::is_empty<enum_UDT>::value)
-   value_test(true, boost::is_empty<boost::noncopyable>::value)
-   value_test(false, boost::is_empty<non_empty>::value)
+   soft_value_test(false, boost::is_empty<enum_UDT>::value)
+   soft_value_test(true, boost::is_empty<boost::noncopyable>::value)
+   soft_value_test(false, boost::is_empty<non_empty>::value)
 
    return check_result(argc, argv);
 }
@@ -170,15 +170,15 @@ int main(int argc, char* argv[])
 // define the number of failures expected for given compilers:
 #ifdef __BORLANDC__
 // can't handle enum's or classes that are POD's
-unsigned int expected_failures = 13;
+unsigned int expected_failures = 10;
 #elif defined(__GNUC__)
 // classes that are POD's, or empty:
-unsigned int expected_failures = 7;
+unsigned int expected_failures = 4;
 #elif defined(BOOST_MSVC)
 // can't handle classes that are POD's or arrays that are POD's
 unsigned int expected_failures = 19;
 #else
-unsigned int expected_failures = 0;
+unsigned int expected_failures = 4;
 #endif