libcxx

libcxx mirror with random patches
git clone https://git.neptards.moe/neptards/libcxx.git
Log | Files | Refs

async.pass.cpp (4366B)

      1 //===----------------------------------------------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is dual licensed under the MIT and the University of Illinois Open
      6 // Source Licenses. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // UNSUPPORTED: libcpp-has-no-threads
     11 // UNSUPPORTED: c++98, c++03
     12 
     13 // <future>
     14 
     15 // template <class F, class... Args>
     16 //     future<typename result_of<F(Args...)>::type>
     17 //     async(F&& f, Args&&... args);
     18 
     19 // template <class F, class... Args>
     20 //     future<typename result_of<F(Args...)>::type>
     21 //     async(launch policy, F&& f, Args&&... args);
     22 
     23 
     24 #include <future>
     25 #include <atomic>
     26 #include <memory>
     27 #include <cassert>
     28 
     29 #include "test_macros.h"
     30 
     31 typedef std::chrono::high_resolution_clock Clock;
     32 typedef std::chrono::milliseconds ms;
     33 
     34 std::atomic_bool invoked = ATOMIC_VAR_INIT(false);
     35 
     36 int f0()
     37 {
     38     invoked = true;
     39     std::this_thread::sleep_for(ms(200));
     40     return 3;
     41 }
     42 
     43 int i = 0;
     44 
     45 int& f1()
     46 {
     47     invoked = true;
     48     std::this_thread::sleep_for(ms(200));
     49     return i;
     50 }
     51 
     52 void f2()
     53 {
     54     invoked = true;
     55     std::this_thread::sleep_for(ms(200));
     56 }
     57 
     58 std::unique_ptr<int> f3(int j)
     59 {
     60     invoked = true;
     61     std::this_thread::sleep_for(ms(200));
     62     return std::unique_ptr<int>(new int(j));
     63 }
     64 
     65 std::unique_ptr<int> f4(std::unique_ptr<int>&& p)
     66 {
     67     invoked = true;
     68     std::this_thread::sleep_for(ms(200));
     69     return std::move(p);
     70 }
     71 
     72 void f5(int j)
     73 {
     74     std::this_thread::sleep_for(ms(200));
     75     ((void)j);
     76     TEST_THROW(j);
     77 }
     78 
     79 template <class Ret, class CheckLamdba, class ...Args>
     80 void test(CheckLamdba&& getAndCheckFn, bool IsDeferred, Args&&... args) {
     81     // Reset global state.
     82     invoked = false;
     83 
     84     // Create the future and wait
     85     std::future<Ret> f = std::async(std::forward<Args>(args)...);
     86     std::this_thread::sleep_for(ms(300));
     87 
     88     // Check that deferred async's have not invoked the function.
     89     assert(invoked == !IsDeferred);
     90 
     91     // Time the call to f.get() and check that the returned value matches
     92     // what is expected.
     93     Clock::time_point t0 = Clock::now();
     94     assert(getAndCheckFn(f));
     95     Clock::time_point t1 = Clock::now();
     96 
     97     // If the async is deferred it should take more than 100ms, otherwise
     98     // it should take less than 100ms.
     99     if (IsDeferred) {
    100         assert(t1-t0 > ms(100));
    101     } else {
    102         assert(t1-t0 < ms(100));
    103     }
    104 }
    105 
    106 int main()
    107 {
    108     // The default launch policy is implementation defined. libc++ defines
    109     // it to be std::launch::async.
    110     bool DefaultPolicyIsDeferred = false;
    111     bool DPID = DefaultPolicyIsDeferred;
    112 
    113     std::launch AnyPolicy = std::launch::async | std::launch::deferred;
    114     LIBCPP_ASSERT(AnyPolicy == std::launch::any);
    115 
    116     {
    117         auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
    118         test<int>(checkInt, DPID,  f0);
    119         test<int>(checkInt, false, std::launch::async, f0);
    120         test<int>(checkInt, true,  std::launch::deferred, f0);
    121         test<int>(checkInt, DPID,  AnyPolicy, f0);
    122     }
    123     {
    124         auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
    125         test<int&>(checkIntRef, DPID,  f1);
    126         test<int&>(checkIntRef, false, std::launch::async, f1);
    127         test<int&>(checkIntRef, true,  std::launch::deferred, f1);
    128         test<int&>(checkIntRef, DPID,  AnyPolicy, f1);
    129     }
    130     {
    131         auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
    132         test<void>(checkVoid, DPID,  f2);
    133         test<void>(checkVoid, false, std::launch::async, f2);
    134         test<void>(checkVoid, true,  std::launch::deferred, f2);
    135         test<void>(checkVoid, DPID,  AnyPolicy, f2);
    136     }
    137     {
    138         using Ret = std::unique_ptr<int>;
    139         auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
    140         test<Ret>(checkUPtr, DPID, f3, 3);
    141         test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
    142     }
    143 #ifndef TEST_HAS_NO_EXCEPTIONS
    144     {
    145         std::future<void> f = std::async(f5, 3);
    146         std::this_thread::sleep_for(ms(300));
    147         try { f.get(); assert (false); } catch ( int ) {}
    148     }
    149     {
    150         std::future<void> f = std::async(std::launch::deferred, f5, 3);
    151         std::this_thread::sleep_for(ms(300));
    152         try { f.get(); assert (false); } catch ( int ) {}
    153     }
    154 #endif
    155 }