Imported Upstream version 1.57.0

[platform/upstream/boost.git] / libs / thread / test / sync / futures / future / get_pass.cpp

diff --git a/libs/thread/test/sync/futures/future/get_pass.cpp b/libs/thread/test/sync/futures/future/get_pass.cpp
index 85b2900..5cd5f81 100755 (executable)
--- a/libs/thread/test/sync/futures/future/get_pass.cpp
+++ b/libs/thread/test/sync/futures/future/get_pass.cpp
@@ -14,16 +14,24 @@
 
 // <boost/thread/future.hpp>
 
-// class promise<R>
+// class future<R>
 
-// future<R> get_future();
+// const R& future::get();
+// R& future<R&>::get();
+// void future<void>::get();
 
-#define BOOST_THREAD_VERSION 3
+//#define BOOST_THREAD_VERSION 3
+#define BOOST_THREAD_VERSION 4
+//#define BOOST_THREAD_USES_LOG
+#define BOOST_THREAD_USES_LOG_THREAD_ID
+#include <boost/thread/detail/log.hpp>
 
 #include <boost/thread/future.hpp>
 #include <boost/thread/thread.hpp>
 #include <boost/detail/lightweight_test.hpp>
 
+#if defined BOOST_THREAD_USES_CHRONO
+
 namespace boost
 {
 template <typename T>
@@ -76,96 +84,181 @@ void func5(boost::promise<void> p)
 void func6(boost::promise<void> p)
 {
     boost::this_thread::sleep_for(boost::chrono::milliseconds(500));
-    p.set_exception(boost::make_exception_ptr('c'));
+    p.set_exception(boost::make_exception_ptr(4));
 }
 
 
 int main()
 {
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
   {
       typedef int T;
       {
           boost::promise<T> p;
           boost::future<T> f = p.get_future();
-          boost::thread(func1, boost::move(p)).detach();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+           boost::thread(func1, boost::move(p)).detach();
+#else
+           p.set_value(3);
+#endif
           BOOST_TEST(f.valid());
           BOOST_TEST(f.get() == 3);
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
           BOOST_TEST(!f.valid());
+#endif
       }
+      BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
       {
           boost::promise<T> p;
+          BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
           boost::future<T> f = p.get_future();
+          BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
           boost::thread(func2, boost::move(p)).detach();
+#else
+          p.set_exception(boost::make_exception_ptr(3));
+#endif
+          BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
           try
           {
+            BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
               BOOST_TEST(f.valid());
+              BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
               BOOST_TEST(f.get() == 3);
+              BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
               BOOST_TEST(false);
+              BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+          }
+          catch (boost::wrap<int> const& i)
+          {
+            BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+              BOOST_TEST(i.value == 3);
+              BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
           }
-          catch (int i)
+          catch (...)
           {
-              BOOST_TEST(i == 3);
+            BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+              BOOST_TEST(false);
+              BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
           }
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+          BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
           BOOST_TEST(!f.valid());
+#endif
+          BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
       }
   }
-//  {
-//      typedef int& T;
-//      {
-//          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
-//          boost::thread(func3, boost::move(p)).detach();
-//          BOOST_TEST(f.valid());
-//          BOOST_TEST(f.get() == 5);
-//          BOOST_TEST(!f.valid());
-//      }
-//      {
-//          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
-//          boost::thread(func4, boost::move(p)).detach();
-//          try
-//          {
-//              BOOST_TEST(f.valid());
-//              BOOST_TEST(f.get() == 3);
-//              BOOST_TEST(false);
-//          }
-//          catch (double i)
-//          {
-//              BOOST_TEST(i == 3.5);
-//          }
-//          BOOST_TEST(!f.valid());
-//      }
-//  }
-//  {
-//      typedef void T;
-//      {
-//          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
-//          boost::thread(func5, boost::move(p)).detach();
-//          BOOST_TEST(f.valid());
-//          f.get();
-//          BOOST_TEST(!f.valid());
-//      }
-//      {
-//          boost::promise<T> p;
-//          boost::future<T> f = p.get_future();
-//          boost::thread(func6, boost::move(p)).detach();
-//          try
-//          {
-//              BOOST_TEST(f.valid());
-//              f.get();
-//              BOOST_TEST(false);
-//          }
-//          catch (char i)
-//          {
-//              BOOST_TEST(i == 'c');
-//          }
-//          BOOST_TEST(!f.valid());
-//      }
-//  }
-
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+  {
+      typedef int& T;
+      {
+          boost::promise<T> p;
+          boost::future<T> f = p.get_future();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+          boost::thread(func3, boost::move(p)).detach();
+#else
+          int j=5;
+          p.set_value(j);
+#endif
+          BOOST_TEST(f.valid());
+          BOOST_TEST(f.get() == 5);
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+          BOOST_TEST(!f.valid());
+#endif
+      }
+      BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+      {
+          boost::promise<T> p;
+          boost::future<T> f = p.get_future();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+          boost::thread(func4, boost::move(p)).detach();
+#else
+          p.set_exception(boost::make_exception_ptr(3.5));
+#endif
+          try
+          {
+              BOOST_TEST(f.valid());
+              BOOST_TEST(f.get() == 3);
+              BOOST_TEST(false);
+          }
+          catch (boost::wrap<double> const& i)
+          {
+              BOOST_TEST(i.value == 3.5);
+          }
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+          BOOST_TEST(!f.valid());
+#endif
+      }
+      BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+      {
+          boost::promise<T> p;
+          boost::future<T> f = p.get_future();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+          boost::thread(func4, boost::move(p)).detach();
+#else
+          p.set_exception(boost::make_exception_ptr(3.5));
+#endif
+          try
+          {
+              BOOST_TEST(f.valid());
+              boost::exception_ptr ptr = f.get_exception_ptr();
+          }
+          catch (...)
+          {
+            BOOST_TEST(false);
+          }
+          BOOST_TEST(f.valid());
+      }
+  }
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 
+  typedef void T;
+  {
+      boost::promise<T> p;
+      boost::future<T> f = p.get_future();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+       boost::thread(func5, boost::move(p)).detach();
+#else
+       p.set_value();
+#endif
+      BOOST_TEST(f.valid());
+      f.get();
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+      BOOST_TEST(!f.valid());
+#endif
+  }
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
+  {
+      boost::promise<T> p;
+      boost::future<T> f = p.get_future();
+#if defined BOOST_THREAD_PROVIDES_SIGNATURE_PACKAGED_TASK && defined(BOOST_THREAD_PROVIDES_VARIADIC_THREAD)
+      boost::thread(func6, boost::move(p)).detach();
+#else
+      p.set_exception(boost::make_exception_ptr(4));
+#endif
+      try
+      {
+          BOOST_TEST(f.valid());
+          f.get();
+          BOOST_TEST(false);
+      }
+      catch (boost::wrap<int> const& i)
+      {
+          BOOST_TEST(i.value == 4);
+      }
+      catch (...)
+      {
+          BOOST_TEST(false);
+      }
+#ifdef BOOST_THREAD_PROVIDES_FUTURE_INVALID_AFTER_GET
+      BOOST_TEST(!f.valid());
+#endif
+  }
+  BOOST_THREAD_LOG << BOOST_THREAD_END_LOG;
 
   return boost::report_errors();
 }
 
+#else
+#error "Test not applicable: BOOST_THREAD_USES_CHRONO not defined for this platform as not supported"
+#endif