1 //===----------------------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 // UNSUPPORTED: c++03, c++11
10
11 #include <experimental/coroutine>
12 #include <cassert>
13 #include <memory>
14
15 #include "test_macros.h"
16 using namespace std::experimental;
17
18 struct error_tag { };
19
20 template <typename T, typename Error = int>
21 struct expected {
22
23 struct Data {
Dataexpected::Data24 Data() : val(), error() { }
Dataexpected::Data25 Data(T v, Error e) : val(v), error(e) { }
26 T val;
27 Error error;
28 };
29 std::shared_ptr<Data> data;
30
expectedexpected31 expected(T val) : data(std::make_shared<Data>(val, Error())) {}
expectedexpected32 expected(error_tag, Error error) : data(std::make_shared<Data>(T(), error)) {}
expectedexpected33 expected(std::shared_ptr<Data> p) : data(p) {}
34
35 struct promise_type {
36 std::shared_ptr<Data> data;
get_return_objectexpected::promise_type37 expected get_return_object() { data = std::make_shared<Data>(); return {data}; }
initial_suspendexpected::promise_type38 suspend_never initial_suspend() { return {}; }
final_suspendexpected::promise_type39 suspend_never final_suspend() noexcept { return {}; }
return_valueexpected::promise_type40 void return_value(T v) { data->val = v; data->error = {}; }
unhandled_exceptionexpected::promise_type41 void unhandled_exception() {}
42 };
43
await_readyexpected44 bool await_ready() { return !data->error; }
await_resumeexpected45 T await_resume() { return data->val; }
await_suspendexpected46 void await_suspend(coroutine_handle<promise_type> h) {
47 h.promise().data->error = data->error;
48 h.destroy();
49 }
50
valueexpected51 T const& value() { return data->val; }
errorexpected52 Error const& error() { return data->error; }
53 };
54
g()55 expected<int> g() { return {0}; }
h()56 expected<int> h() { return {error_tag{}, 42}; }
57
58 extern "C" void print(int);
59
60 bool f1_started, f1_resumed = false;
f1()61 expected<int> f1() {
62 f1_started = true;
63 (void)(co_await g());
64 f1_resumed = true;
65 co_return 100;
66 }
67
68 bool f2_started, f2_resumed = false;
f2()69 expected<int> f2() {
70 f2_started = true;
71 (void)(co_await h());
72 f2_resumed = true;
73 co_return 200;
74 }
75
main(int,char **)76 int main(int, char**) {
77 auto c1 = f1();
78 assert(f1_started && f1_resumed);
79 assert(c1.value() == 100);
80 assert(c1.error() == 0);
81
82 auto c2 = f2();
83 assert(f2_started && !f2_resumed);
84 assert(c2.value() == 0);
85 assert(c2.error() == 42);
86
87 return 0;
88 }
89