TheRock/compiler/amd-llvm/libcxx/test/std/thread/futures/futures.async/async.pass.cpp

//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// UNSUPPORTED: no-threads
// UNSUPPORTED: c++03

// ALLOW_RETRIES: 3

// <future>

// template <class F, class... Args>
//     future<typename result_of<F(Args...)>::type>
//     async(F&& f, Args&&... args);

// template <class F, class... Args>
//     future<typename result_of<F(Args...)>::type>
//     async(launch policy, F&& f, Args&&... args);


#include <atomic>
#include <cassert>
#include <chrono>
#include <future>
#include <memory>
#include <thread>

#include "test_macros.h"

typedef std::chrono::high_resolution_clock Clock;
typedef std::chrono::milliseconds ms;

std::atomic_bool invoked{false};

int f0()
{
    invoked = true;
    std::this_thread::sleep_for(ms(200));
    return 3;
}

int i = 0;

int& f1()
{
    invoked = true;
    std::this_thread::sleep_for(ms(200));
    return i;
}

void f2()
{
    invoked = true;
    std::this_thread::sleep_for(ms(200));
}

std::unique_ptr<int> f3(int j)
{
    invoked = true;
    std::this_thread::sleep_for(ms(200));
    return std::unique_ptr<int>(new int(j));
}

std::unique_ptr<int> f4(std::unique_ptr<int>&& p)
{
    invoked = true;
    std::this_thread::sleep_for(ms(200));
    return std::move(p);
}

void f5(int j)
{
    std::this_thread::sleep_for(ms(200));
    ((void)j);
    TEST_THROW(j);
}

template <class Ret, class CheckLambda, class... Args>
void test(CheckLambda&& getAndCheckFn, bool IsDeferred, Args&&... args) {
  // Reset global state.
  invoked = false;

  // Create the future and wait
  std::future<Ret> f = std::async(std::forward<Args>(args)...);
  std::this_thread::sleep_for(ms(300));

  // Check that deferred async's have not invoked the function.
  assert(invoked == !IsDeferred);

  // Time the call to f.get() and check that the returned value matches
  // what is expected.
  Clock::time_point t0 = Clock::now();
  assert(getAndCheckFn(f));
  Clock::time_point t1 = Clock::now();

  // If the async is deferred it should take more than 100ms, otherwise
  // it should take less than 100ms.
  if (IsDeferred) {
    assert(t1 - t0 > ms(100));
  } else {
    assert(t1 - t0 < ms(100));
  }
}

int main(int, char**)
{
    // The default launch policy is implementation defined. libc++ defines
    // it to be std::launch::async.
    bool DefaultPolicyIsDeferred = false;
    bool DPID = DefaultPolicyIsDeferred;

    std::launch AnyPolicy = std::launch::async | std::launch::deferred;

    {
        auto checkInt = [](std::future<int>& f) { return f.get() == 3; };
        test<int>(checkInt, DPID,  f0);
        test<int>(checkInt, false, std::launch::async, f0);
        test<int>(checkInt, true,  std::launch::deferred, f0);
        test<int>(checkInt, DPID,  AnyPolicy, f0);
    }
    {
        auto checkIntRef = [&](std::future<int&>& f) { return &f.get() == &i; };
        test<int&>(checkIntRef, DPID,  f1);
        test<int&>(checkIntRef, false, std::launch::async, f1);
        test<int&>(checkIntRef, true,  std::launch::deferred, f1);
        test<int&>(checkIntRef, DPID,  AnyPolicy, f1);
    }
    {
        auto checkVoid = [](std::future<void>& f) { f.get(); return true; };
        test<void>(checkVoid, DPID,  f2);
        test<void>(checkVoid, false, std::launch::async, f2);
        test<void>(checkVoid, true,  std::launch::deferred, f2);
        test<void>(checkVoid, DPID,  AnyPolicy, f2);
    }
    {
        using Ret = std::unique_ptr<int>;
        auto checkUPtr = [](std::future<Ret>& f) { return *f.get() == 3; };
        test<Ret>(checkUPtr, DPID, f3, 3);
        test<Ret>(checkUPtr, DPID, f4, std::unique_ptr<int>(new int(3)));
    }
#ifndef TEST_HAS_NO_EXCEPTIONS
    {
        std::future<void> f = std::async(f5, 3);
        std::this_thread::sleep_for(ms(300));
        try { f.get(); assert (false); } catch ( int ) {}
    }
    {
        std::future<void> f = std::async(std::launch::deferred, f5, 3);
        std::this_thread::sleep_for(ms(300));
        try { f.get(); assert (false); } catch ( int ) {}
    }
#endif
    {
      class CopyOnly {
      public:
        CopyOnly() {}
        CopyOnly(const CopyOnly&) = default;
        CopyOnly(CopyOnly&&)      = delete;

        void operator()(const CopyOnly&) const {}
      };
      CopyOnly c;
      std::future<void> f = std::async(c, c);
      f.wait();
    }
    {
      class MoveOnly {
      public:
        MoveOnly() {}
        MoveOnly(const MoveOnly&) = delete;
        MoveOnly(MoveOnly&&)      = default;

        void operator()(MoveOnly&&) const {}
      };
      std::future<void> f = std::async(MoveOnly{}, MoveOnly{});
      f.wait();
    }
    return 0;
}