Committing changes merged from trunk, most notably optional non-intrusive exception_ptr support for MSVC.

[SVN r70974]

test/Jamfile.v2

@@ -7,7 +7,13 @@
 
 import testing ;
 
-project : requirements <exception-handling>on ;
+project
+  : requirements
+      <link>static
+      <exception-handling>on
+      <source>/boost//exception
+      <define>BOOST_ENABLE_NON_INTRUSIVE_EXCEPTION_PTR
+      ;
 
 #to_string
 
@@ -37,6 +43,7 @@ run current_exception_cast_test.cpp ;
 run no_exceptions_test.cpp : : : <exception-handling>off ;
 run errinfos_test.cpp ;
 run exception_ptr_test.cpp /boost//thread : : : <threading>multi ;
+
 compile-fail exception_fail.cpp ;
 compile-fail throw_exception_fail.cpp ;
 compile-fail error_info_const_fail.cpp ;

test/cloning_test.cpp

@@ -146,6 +146,10 @@ test_std_exception()
 #endif
             }
         catch(
+        T & )
+            {
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -176,7 +180,7 @@ test_std_exception_what()
         catch(
         T & x )
             {
-            BOOST_TEST(std::string("what")==x.what());
+            BOOST_TEST(std::string(x.what()).find("what")!=std::string::npos);
             boost::exception_ptr p = boost::current_exception();
             BOOST_TEST(!(p==boost::exception_ptr()));
             BOOST_TEST(p!=boost::exception_ptr());
@@ -189,7 +193,7 @@ test_std_exception_what()
             catch(
             T & x )
                 {
-                BOOST_TEST(std::string("what")==x.what());
+                BOOST_TEST(std::string(x.what()).find("what")!=std::string::npos);
                 }
             catch(
             ... )
@@ -216,6 +220,10 @@ test_std_exception_what()
 #endif
             }
         catch(
+        T & )
+            {
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -385,6 +393,11 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_std_exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         boost::unknown_exception & e )
             {
 #ifndef BOOST_NO_RTTI
@@ -434,6 +447,14 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_std_boost_exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            BOOST_TEST(boost::get_error_info<my_info>(x));
+            if( int const * p=boost::get_error_info<my_info>(x) )
+                BOOST_TEST(*p==42);
+            }
+        catch(
         boost::unknown_exception & x )
             {
             BOOST_TEST(boost::get_error_info<my_info>(x));
@@ -495,6 +516,14 @@ main()
             BOOST_TEST(false);
             }
         catch(
+        derives_boost_exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            BOOST_TEST(boost::get_error_info<my_info>(x));
+            if( int const * p=boost::get_error_info<my_info>(x) )
+                BOOST_TEST(*p==42);
+            }
+        catch(
         boost::unknown_exception & x )
             {
             BOOST_TEST(boost::get_error_info<my_info>(x));

test/copy_exception_test.cpp

@@ -6,15 +6,37 @@
 #include <boost/exception_ptr.hpp>
 #include <boost/exception/get_error_info.hpp>
 #include <boost/thread.hpp>
+#include <boost/detail/atomic_count.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
 typedef boost::error_info<struct tag_answer,int> answer;
 
+boost::detail::atomic_count exc_count(0);
+
 struct
 err:
     virtual boost::exception,
     virtual std::exception
     {
+    err()
+        {
+        ++exc_count;
+        }
+
+    err( err const & )
+        {
+        ++exc_count;
+        }
+
+    virtual
+    ~err() throw()
+        {
+        --exc_count;
+        }
+
+    private:
+
+    err & operator=( err const & );
     };
 
 class
@@ -116,7 +138,9 @@ simple_test()
 int
 main()
     {
+    BOOST_TEST(++exc_count==1);
     simple_test();
     thread_test();
+    BOOST_TEST(!--exc_count);
     return boost::report_errors();
     }

test/exception_ptr_test.cpp

@@ -10,6 +10,7 @@
 #include <boost/function.hpp>
 #include <boost/bind.hpp>
 #include <boost/thread.hpp>
+#include <boost/detail/atomic_count.hpp>
 #include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 
@@ -66,7 +67,34 @@ join( thread_handle & t )
         rethrow_exception(t.err_);
     }
 
-struct exc: boost::exception, std::exception { };
+boost::detail::atomic_count exc_count(0);
+
+struct
+exc:
+    virtual boost::exception,
+    virtual std::exception
+    {
+    exc()
+        {
+        ++exc_count;
+        }
+
+    exc( exc const & )
+        {
+        ++exc_count;
+        }
+
+    virtual
+    ~exc() throw()
+        {
+        --exc_count;
+        }
+
+    private:
+
+    exc & operator=( exc const & );
+    };
+
 typedef boost::error_info<struct answer_,int> answer;
 
 void
@@ -93,6 +121,7 @@ check( boost::shared_ptr<thread_handle> const & t )
 int
 main()
     {
+    BOOST_TEST(++exc_count==1);
     try
         {
         std::vector< boost::shared_ptr<thread_handle> > threads;
@@ -109,4 +138,5 @@ main()
             boost::current_exception_diagnostic_information() << std::endl;
         return 42;
         }
+    BOOST_TEST(!--exc_count);
     }

test/unknown_exception_test.cpp

@@ -62,6 +62,15 @@ main()
                 BOOST_TEST(false);
             }
         catch(
+        boost::exception & x )
+            {
+            //Yay! Non-intrusive cloning supported!
+            if( int const * d=boost::get_error_info<test>(x) )
+                BOOST_TEST( 42==*d );
+            else
+                BOOST_TEST(false);
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -101,6 +110,11 @@ main()
             {
             }
         catch(
+        std::exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);
@@ -114,6 +128,11 @@ main()
             {
             }
         catch(
+        std::exception & )
+            {
+            //Yay! Non-intrusive cloning supported!
+            }
+        catch(
         ... )
             {
             BOOST_TEST(false);