Create a branch for inspect fixes.

[SVN r61439]

doc/Jamfile.v2

@@ -6,4 +6,10 @@ doxygen reference : [ glob ../../../boost/logic/tribool.hpp ]
                     [ glob ../../../boost/logic/tribool_fwd.hpp ]
                     [ glob ../../../boost/logic/tribool_io.hpp ]
                   ;
-boostbook tribool : tribool.boostbook ;
+boostbook tribool 
+	: 
+	tribool.boostbook 
+	:
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+        <dependency>reference
+	;

doc/tribool.boostbook

@@ -2,7 +2,7 @@
 <!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
   "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
 <library name="Tribool" dirname="logic" id="tribool"
-         last-revision="$Date: 2004/07/25 03:01:38 $" xmlns:xi="http://www.w3.org/2001/XInclude">
+         last-revision="$Date: 2007/05/03 03:28:53 $" xmlns:xi="http://www.w3.org/2001/XInclude">
   <libraryinfo>
     <author>
       <firstname>Douglas</firstname>
@@ -197,7 +197,7 @@ cout &lt;&lt; boolalpha &lt;&lt; x &lt;&lt; endl; // Prints "maybe"</programlist
 
   </section>
 
-  <xi:include href="reference.boostbook"/>
+  <xi:include href="reference.xml"/>
 
   <testsuite id="tribool.tests">
     <run-test filename="tribool_test.cpp">

include/boost/logic/tribool.hpp

@@ -93,7 +93,7 @@ public:
    *
    * \throws nothrow
    */
-  tribool(bool value) : value(value? true_value : false_value) {}
+  tribool(bool initial_value) : value(initial_value? true_value : false_value) {}
 
   /**
    * Construct a new 3-state boolean value with an indeterminate value.
@@ -118,7 +118,7 @@ public:
    * The actual stored value in this 3-state boolean, which may be false, true,
    * or indeterminate.
    */
-  enum { false_value, true_value, indeterminate_value } value;
+  enum value_t { false_value, true_value, indeterminate_value } value;
 };
 
 // Check if the given tribool has an indeterminate value. Also doubles as a
@@ -336,7 +336,7 @@ inline tribool operator==(tribool x, tribool y)
   if (indeterminate(x) || indeterminate(y))
     return indeterminate;
   else
-    return x && y || !x && !y;
+    return (x && y) || (!x && !y);
 }
 
 /**
@@ -399,7 +399,7 @@ inline tribool operator!=(tribool x, tribool y)
   if (indeterminate(x) || indeterminate(y))
     return indeterminate;
   else
-    return !(x && y || !x && !y);
+    return !((x && y) || (!x && !y));
 }
 
 /**
@@ -452,7 +452,7 @@ namespace boost {
 #define BOOST_TRIBOOL_THIRD_STATE(Name)                                 \
 inline bool                                                             \
 Name(boost::logic::tribool x,                                           \
-     boost::logic::detail::indeterminate_t dummy =                      \
+     boost::logic::detail::indeterminate_t =                            \
        boost::logic::detail::indeterminate_t())                         \
 { return x.value == boost::logic::tribool::indeterminate_value; }
 

include/boost/logic/tribool_io.hpp

@@ -104,9 +104,10 @@ template<>
 inline std::basic_string<char> get_default_indeterminate_name<char>()
 { return "indeterminate"; }
 
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
 // VC++ 6.0 chokes on the specialization below, so we're stuck without 
-// wchar_t support. What a pain.
+// wchar_t support. What a pain. TODO: it might just need a the template 
+// parameter as function parameter...
 #else
 #  ifndef BOOST_NO_WCHAR_T
 /// Returns the wide character string L"indeterminate".
@@ -139,7 +140,8 @@ public:
   indeterminate_name() : name_(get_default_indeterminate_name<CharT>()) {}
 
   /// Construct the facet with the given name for the indeterminate value
-  explicit indeterminate_name(const string_type& name) : name_(name) {}
+  explicit indeterminate_name(const string_type& initial_name)
+  : name_(initial_name) {}
 
   /// Returns the name for the indeterminate value
   string_type name() const { return name_; }
@@ -201,6 +203,26 @@ operator<<(std::basic_ostream<CharT, Traits>& out, tribool x)
   return out;
 }
 
+/**
+ * \brief Writes the indeterminate tribool value to a stream.
+ *
+ * This routine outputs either the integer
+ * value 2 (if <tt>(out.flags() & std::ios_base::boolalpha) == 0</tt>)
+ * or the name of the indeterminate value. The name of the
+ * indeterminate value comes from the indeterminate_name facet (if it
+ * is defined in the output stream's locale), or from the
+ * get_default_indeterminate_name function (if it is not defined in the
+ * locale or if the C++ standard library implementation does not
+ * support locales).
+ *
+ * \returns @p out
+ */
+template<typename CharT, typename Traits>
+inline std::basic_ostream<CharT, Traits>&
+operator<<(std::basic_ostream<CharT, Traits>& out, 
+           bool (*)(tribool, detail::indeterminate_t))
+{ return out << tribool(indeterminate); } 
+
 /**
  * \brief Reads a tribool value from a stream.
  *

test/Jamfile

@@ -1,35 +0,0 @@
-# Tribool library
-
-# Copyright (C) 2002-2003 Douglas Gregor
-
-# Use, modification and distribution is subject to 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) 
-
-# For more information, see http://www.boost.org/
-
-
-# Testing Jamfile autogenerated from XML source
-subproject libs/logic/test ;
-
-# bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-  # look in BOOST_ROOT for sources first, just in this Jamfile
-  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-  test-suite logic
-    : 
-    [ run libs/logic/test/tribool_test.cpp :  :  :  :  ]
-
-    [ run libs/logic/test/tribool_rename_test.cpp :  :  :  :  ]
-
-    [ run libs/logic/test/tribool_io_test.cpp :  :  :  :  ]
-   ;
-}
-      

test/Jamfile.v2

@@ -0,0 +1,17 @@
+# Tribool library
+
+# Copyright (C) 2002-2003 Douglas Gregor
+
+# Use, modification and distribution is subject to 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) 
+
+# For more information, see http://www.boost.org/
+
+  test-suite logic  : 
+    [ run tribool_test.cpp ]
+    [ run tribool_rename_test.cpp ]
+    [ run tribool_io_test.cpp ]
+   ;
+
+      

test/tribool_io_test.cpp

@@ -8,6 +8,7 @@
 #include <sstream>
 #include <string>
 #include <iostream>
+#include <ios>     // for std::boolalpha
 
 #ifndef BOOST_NO_STD_LOCALE
 #  include <locale>
@@ -27,14 +28,14 @@ int test_main(int, char*[])
   x = false;
   out << x;
   std::cout << "Output false (noboolalpha): " << out.str() << std::endl;
-  BOOST_TEST(out.str() == "0");
+  BOOST_CHECK(out.str() == "0");
 
   // Output true (noboolalpha)
   out.str(std::string());
   x = true;
   out << x;
   std::cout << "Output true (noboolalpha): " << out.str() << std::endl;
-  BOOST_TEST(out.str() == "1");
+  BOOST_CHECK(out.str() == "1");
 
   // Output indeterminate (noboolalpha)
   out.str(std::string());
@@ -42,7 +43,14 @@ int test_main(int, char*[])
   out << x;
   std::cout << "Output indeterminate (noboolalpha): " << out.str()
             << std::endl;
-  BOOST_TEST(out.str() == "2");
+  BOOST_CHECK(out.str() == "2");
+
+  // Output indeterminate (noboolalpha)
+  out.str(std::string());
+  out << indeterminate;
+  std::cout << "Output indeterminate (noboolalpha): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "2");
 
 #ifndef BOOST_NO_STD_LOCALE
   const std::numpunct<char>& punct =
@@ -53,7 +61,7 @@ int test_main(int, char*[])
   x = false;
   out << std::boolalpha << x;
   std::cout << "Output false (boolalpha): " << out.str() << std::endl;
-  BOOST_TEST(out.str() == punct.falsename());
+  BOOST_CHECK(out.str() == punct.falsename());
 
   // Output true (boolalpha)
   out.str(std::string());
@@ -61,7 +69,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output true (boolalpha): " << out.str() << std::endl;
 
-  BOOST_TEST(out.str() == punct.truename());
+  BOOST_CHECK(out.str() == punct.truename());
 
   // Output indeterminate (boolalpha - default name)
   out.str(std::string());
@@ -69,7 +77,14 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
             << std::endl;
-  BOOST_TEST(out.str() == "indeterminate");
+  BOOST_CHECK(out.str() == "indeterminate");
+
+  // Output indeterminate (boolalpha - default name)
+  out.str(std::string());
+  out << std::boolalpha << indeterminate;
+  std::cout << "Output indeterminate (boolalpha - default name): " << out.str()
+            << std::endl;
+  BOOST_CHECK(out.str() == "indeterminate");
 
 #  if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
   // No template constructors, so we can't build the test locale
@@ -82,7 +97,7 @@ int test_main(int, char*[])
   out << std::boolalpha << x;
   std::cout << "Output indeterminate (boolalpha - \"maybe\"): " << out.str()
             << std::endl;
-  BOOST_TEST(out.str() == "maybe");
+  BOOST_CHECK(out.str() == "maybe");
 #  endif
 #endif // ! BOOST_NO_STD_LOCALE
 
@@ -93,7 +108,7 @@ int test_main(int, char*[])
     std::istringstream in("0");
     std::cout << "Input \"0\" (checks for false)" << std::endl;
     in >> x;
-    BOOST_TEST(x == false);
+    BOOST_CHECK(x == false);
   }
 
   // Input true (noboolalpha)
@@ -101,7 +116,7 @@ int test_main(int, char*[])
     std::istringstream in("1");
     std::cout << "Input \"1\" (checks for true)" << std::endl;
     in >> x;
-    BOOST_TEST(x == true);
+    BOOST_CHECK(x == true);
   }
 
   // Input false (noboolalpha)
@@ -109,14 +124,14 @@ int test_main(int, char*[])
     std::istringstream in("2");
     std::cout << "Input \"2\" (checks for indeterminate)" << std::endl;
     in >> x;
-    BOOST_TEST(indeterminate(x));
+    BOOST_CHECK(indeterminate(x));
   }
 
   // Input bad number (noboolalpha)
   {
     std::istringstream in("3");
     std::cout << "Input \"3\" (checks for failure)" << std::endl;
-    BOOST_TEST(!(in >> x));
+    BOOST_CHECK(!(in >> x));
   }
 
   // Input false (boolalpha)
@@ -124,7 +139,7 @@ int test_main(int, char*[])
     std::istringstream in("false");
     std::cout << "Input \"false\" (checks for false)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_TEST(x == false);
+    BOOST_CHECK(x == false);
   }
 
   // Input true (boolalpha)
@@ -132,7 +147,7 @@ int test_main(int, char*[])
     std::istringstream in("true");
     std::cout << "Input \"true\" (checks for true)" << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_TEST(x == true);
+    BOOST_CHECK(x == true);
   }
 
   // Input indeterminate (boolalpha)
@@ -141,7 +156,7 @@ int test_main(int, char*[])
     std::cout << "Input \"indeterminate\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_TEST(indeterminate(x));
+    BOOST_CHECK(indeterminate(x));
   }
 
   // Input bad string (boolalpha)
@@ -149,7 +164,7 @@ int test_main(int, char*[])
     std::istringstream in("bad");
     std::cout << "Input \"bad\" (checks for failure)"
               << std::endl;
-    BOOST_TEST(!(in >> std::boolalpha >> x));
+    BOOST_CHECK(!(in >> std::boolalpha >> x));
   }
 
 #if BOOST_WORKAROUND(BOOST_DINKUMWARE_STDLIB, == 1)
@@ -163,7 +178,7 @@ int test_main(int, char*[])
     std::cout << "Input \"maybe\" (checks for indeterminate, uses locales)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_TEST(indeterminate(x));
+    BOOST_CHECK(indeterminate(x));
   }
 
   // Input indeterminate named "true_or_false" (boolalpha)
@@ -175,7 +190,7 @@ int test_main(int, char*[])
     std::cout << "Input \"true_or_false\" (checks for indeterminate)"
               << std::endl;
     in >> std::boolalpha >> x;
-    BOOST_TEST(indeterminate(x));
+    BOOST_CHECK(indeterminate(x));
   }
 #endif
 

test/tribool_rename_test.cpp

@@ -19,103 +19,103 @@ int test_main(int,char*[])
   tribool y(true); // true
   tribool z(maybe); // maybe
 
-  BOOST_TEST(!x);
-  BOOST_TEST(x == false);
-  BOOST_TEST(false == x);
-  BOOST_TEST(x != true);
-  BOOST_TEST(true != x);
-  BOOST_TEST(maybe(x == maybe));
-  BOOST_TEST(maybe(maybe == x));
-  BOOST_TEST(maybe(x != maybe));
-  BOOST_TEST(maybe(maybe != x));
-  BOOST_TEST(x == x);
-  BOOST_TEST(!(x != x));
-  BOOST_TEST(!(x && true));
-  BOOST_TEST(!(true && x));
-  BOOST_TEST(x || true);
-  BOOST_TEST(true || x);
+  BOOST_CHECK(!x);
+  BOOST_CHECK(x == false);
+  BOOST_CHECK(false == x);
+  BOOST_CHECK(x != true);
+  BOOST_CHECK(true != x);
+  BOOST_CHECK(maybe(x == maybe));
+  BOOST_CHECK(maybe(maybe == x));
+  BOOST_CHECK(maybe(x != maybe));
+  BOOST_CHECK(maybe(maybe != x));
+  BOOST_CHECK(x == x);
+  BOOST_CHECK(!(x != x));
+  BOOST_CHECK(!(x && true));
+  BOOST_CHECK(!(true && x));
+  BOOST_CHECK(x || true);
+  BOOST_CHECK(true || x);
 
-  BOOST_TEST(y);
-  BOOST_TEST(y == true);
-  BOOST_TEST(true == y);
-  BOOST_TEST(y != false);
-  BOOST_TEST(false != y);
-  BOOST_TEST(maybe(y == maybe));
-  BOOST_TEST(maybe(maybe == y));
-  BOOST_TEST(maybe(y != maybe));
-  BOOST_TEST(maybe(maybe != y));
-  BOOST_TEST(y == y);
-  BOOST_TEST(!(y != y));
+  BOOST_CHECK(y);
+  BOOST_CHECK(y == true);
+  BOOST_CHECK(true == y);
+  BOOST_CHECK(y != false);
+  BOOST_CHECK(false != y);
+  BOOST_CHECK(maybe(y == maybe));
+  BOOST_CHECK(maybe(maybe == y));
+  BOOST_CHECK(maybe(y != maybe));
+  BOOST_CHECK(maybe(maybe != y));
+  BOOST_CHECK(y == y);
+  BOOST_CHECK(!(y != y));
 
-  BOOST_TEST(maybe(z || !z));
-  BOOST_TEST(maybe(z == true));
-  BOOST_TEST(maybe(true == z));
-  BOOST_TEST(maybe(z == false));
-  BOOST_TEST(maybe(false == z));
-  BOOST_TEST(maybe(z == maybe));
-  BOOST_TEST(maybe(maybe == z));
-  BOOST_TEST(maybe(z != maybe));
-  BOOST_TEST(maybe(maybe != z));
-  BOOST_TEST(maybe(z == z));
-  BOOST_TEST(maybe(z != z));
+  BOOST_CHECK(maybe(z || !z));
+  BOOST_CHECK(maybe(z == true));
+  BOOST_CHECK(maybe(true == z));
+  BOOST_CHECK(maybe(z == false));
+  BOOST_CHECK(maybe(false == z));
+  BOOST_CHECK(maybe(z == maybe));
+  BOOST_CHECK(maybe(maybe == z));
+  BOOST_CHECK(maybe(z != maybe));
+  BOOST_CHECK(maybe(maybe != z));
+  BOOST_CHECK(maybe(z == z));
+  BOOST_CHECK(maybe(z != z));
 
-  BOOST_TEST(!(x == y));
-  BOOST_TEST(x != y);
-  BOOST_TEST(maybe(x == z));
-  BOOST_TEST(maybe(x != z));
-  BOOST_TEST(maybe(y == z));
-  BOOST_TEST(maybe(y != z));
+  BOOST_CHECK(!(x == y));
+  BOOST_CHECK(x != y);
+  BOOST_CHECK(maybe(x == z));
+  BOOST_CHECK(maybe(x != z));
+  BOOST_CHECK(maybe(y == z));
+  BOOST_CHECK(maybe(y != z));
 
-  BOOST_TEST(!(x && y));
-  BOOST_TEST(x || y);
-  BOOST_TEST(!(x && z));
-  BOOST_TEST(maybe(y && z));
-  BOOST_TEST(maybe(z && z));
-  BOOST_TEST(maybe(z || z));
-  BOOST_TEST(maybe(x || z));
-  BOOST_TEST(y || z);
+  BOOST_CHECK(!(x && y));
+  BOOST_CHECK(x || y);
+  BOOST_CHECK(!(x && z));
+  BOOST_CHECK(maybe(y && z));
+  BOOST_CHECK(maybe(z && z));
+  BOOST_CHECK(maybe(z || z));
+  BOOST_CHECK(maybe(x || z));
+  BOOST_CHECK(y || z);
 
-  BOOST_TEST(maybe(y && maybe));
-  BOOST_TEST(maybe(maybe && y));
-  BOOST_TEST(!(x && maybe));
-  BOOST_TEST(!(maybe && x));
+  BOOST_CHECK(maybe(y && maybe));
+  BOOST_CHECK(maybe(maybe && y));
+  BOOST_CHECK(!(x && maybe));
+  BOOST_CHECK(!(maybe && x));
 
-  BOOST_TEST(maybe || y);
-  BOOST_TEST(y || maybe);
-  BOOST_TEST(maybe(x || maybe));
-  BOOST_TEST(maybe(maybe || x));
+  BOOST_CHECK(maybe || y);
+  BOOST_CHECK(y || maybe);
+  BOOST_CHECK(maybe(x || maybe));
+  BOOST_CHECK(maybe(maybe || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else if (!z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
 
   z = true;
   if (z) {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
   else if (!z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
 
   z = false;
   if (z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else if (!z) {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
   else {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
 
   std::cout << "no errors detected\n";

test/tribool_test.cpp

@@ -15,103 +15,103 @@ int test_main(int, char*[])
   tribool y(true); // true
   tribool z(indeterminate); // indeterminate
 
-  BOOST_TEST(!x);
-  BOOST_TEST(x == false);
-  BOOST_TEST(false == x);
-  BOOST_TEST(x != true);
-  BOOST_TEST(true != x);
-  BOOST_TEST(indeterminate(x == indeterminate));
-  BOOST_TEST(indeterminate(indeterminate == x));
-  BOOST_TEST(indeterminate(x != indeterminate));
-  BOOST_TEST(indeterminate(indeterminate != x));
-  BOOST_TEST(x == x);
-  BOOST_TEST(!(x != x));
-  BOOST_TEST(!(x && true));
-  BOOST_TEST(!(true && x));
-  BOOST_TEST(x || true);
-  BOOST_TEST(true || x);
+  BOOST_CHECK(!x);
+  BOOST_CHECK(x == false);
+  BOOST_CHECK(false == x);
+  BOOST_CHECK(x != true);
+  BOOST_CHECK(true != x);
+  BOOST_CHECK(indeterminate(x == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == x));
+  BOOST_CHECK(indeterminate(x != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != x));
+  BOOST_CHECK(x == x);
+  BOOST_CHECK(!(x != x));
+  BOOST_CHECK(!(x && true));
+  BOOST_CHECK(!(true && x));
+  BOOST_CHECK(x || true);
+  BOOST_CHECK(true || x);
 
-  BOOST_TEST(y);
-  BOOST_TEST(y == true);
-  BOOST_TEST(true == y);
-  BOOST_TEST(y != false);
-  BOOST_TEST(false != y);
-  BOOST_TEST(indeterminate(y == indeterminate));
-  BOOST_TEST(indeterminate(indeterminate == y));
-  BOOST_TEST(indeterminate(y != indeterminate));
-  BOOST_TEST(indeterminate(indeterminate != y));
-  BOOST_TEST(y == y);
-  BOOST_TEST(!(y != y));
+  BOOST_CHECK(y);
+  BOOST_CHECK(y == true);
+  BOOST_CHECK(true == y);
+  BOOST_CHECK(y != false);
+  BOOST_CHECK(false != y);
+  BOOST_CHECK(indeterminate(y == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == y));
+  BOOST_CHECK(indeterminate(y != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != y));
+  BOOST_CHECK(y == y);
+  BOOST_CHECK(!(y != y));
 
-  BOOST_TEST(indeterminate(z || !z));
-  BOOST_TEST(indeterminate(z == true));
-  BOOST_TEST(indeterminate(true == z));
-  BOOST_TEST(indeterminate(z == false));
-  BOOST_TEST(indeterminate(false == z));
-  BOOST_TEST(indeterminate(z == indeterminate));
-  BOOST_TEST(indeterminate(indeterminate == z));
-  BOOST_TEST(indeterminate(z != indeterminate));
-  BOOST_TEST(indeterminate(indeterminate != z));
-  BOOST_TEST(indeterminate(z == z));
-  BOOST_TEST(indeterminate(z != z));
+  BOOST_CHECK(indeterminate(z || !z));
+  BOOST_CHECK(indeterminate(z == true));
+  BOOST_CHECK(indeterminate(true == z));
+  BOOST_CHECK(indeterminate(z == false));
+  BOOST_CHECK(indeterminate(false == z));
+  BOOST_CHECK(indeterminate(z == indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate == z));
+  BOOST_CHECK(indeterminate(z != indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate != z));
+  BOOST_CHECK(indeterminate(z == z));
+  BOOST_CHECK(indeterminate(z != z));
 
-  BOOST_TEST(!(x == y));
-  BOOST_TEST(x != y);
-  BOOST_TEST(indeterminate(x == z));
-  BOOST_TEST(indeterminate(x != z));
-  BOOST_TEST(indeterminate(y == z));
-  BOOST_TEST(indeterminate(y != z));
+  BOOST_CHECK(!(x == y));
+  BOOST_CHECK(x != y);
+  BOOST_CHECK(indeterminate(x == z));
+  BOOST_CHECK(indeterminate(x != z));
+  BOOST_CHECK(indeterminate(y == z));
+  BOOST_CHECK(indeterminate(y != z));
 
-  BOOST_TEST(!(x && y));
-  BOOST_TEST(x || y);
-  BOOST_TEST(!(x && z));
-  BOOST_TEST(indeterminate(y && z));
-  BOOST_TEST(indeterminate(z && z));
-  BOOST_TEST(indeterminate(z || z));
-  BOOST_TEST(indeterminate(x || z));
-  BOOST_TEST(y || z);
+  BOOST_CHECK(!(x && y));
+  BOOST_CHECK(x || y);
+  BOOST_CHECK(!(x && z));
+  BOOST_CHECK(indeterminate(y && z));
+  BOOST_CHECK(indeterminate(z && z));
+  BOOST_CHECK(indeterminate(z || z));
+  BOOST_CHECK(indeterminate(x || z));
+  BOOST_CHECK(y || z);
 
-  BOOST_TEST(indeterminate(y && indeterminate));
-  BOOST_TEST(indeterminate(indeterminate && y));
-  BOOST_TEST(!(x && indeterminate));
-  BOOST_TEST(!(indeterminate && x));
+  BOOST_CHECK(indeterminate(y && indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate && y));
+  BOOST_CHECK(!(x && indeterminate));
+  BOOST_CHECK(!(indeterminate && x));
 
-  BOOST_TEST(indeterminate || y);
-  BOOST_TEST(y || indeterminate);
-  BOOST_TEST(indeterminate(x || indeterminate));
-  BOOST_TEST(indeterminate(indeterminate || x));
+  BOOST_CHECK(indeterminate || y);
+  BOOST_CHECK(y || indeterminate);
+  BOOST_CHECK(indeterminate(x || indeterminate));
+  BOOST_CHECK(indeterminate(indeterminate || x));
 
   // Test the if (z) ... else (!z) ... else ... idiom
   if (z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else if (!z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
 
   z = true;
   if (z) {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
   else if (!z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
 
   z = false;
   if (z) {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
   else if (!z) {
-    BOOST_TEST(true);
+    BOOST_CHECK(true);
   }
   else {
-    BOOST_TEST(false);
+    BOOST_CHECK(false);
   }
 
   std::cout << "no errors detected\n";