1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
/*
* Copyright 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <ftl/future.h>
#include <gtest/gtest.h>
#include <algorithm>
#include <future>
#include <string>
#include <thread>
#include <vector>
namespace android::test {
// Keep in sync with example usage in header file.
TEST(Future, Example) {
{
auto future = ftl::defer([](int x) { return x + 1; }, 99);
EXPECT_EQ(future.get(), 100);
}
{
auto future = ftl::yield(42);
EXPECT_EQ(future.get(), 42);
}
{
auto ptr = std::make_unique<char>('!');
auto future = ftl::yield(std::move(ptr));
EXPECT_EQ(*future.get(), '!');
}
{
auto future = ftl::yield(123);
std::future<char> futures[] = {ftl::yield('a'), ftl::yield('b')};
std::future<char> chain = ftl::chain(std::move(future))
.then([](int x) { return static_cast<size_t>(x % 2); })
.then([&futures](size_t i) { return std::move(futures[i]); });
EXPECT_EQ(chain.get(), 'b');
}
}
namespace {
using ByteVector = std::vector<uint8_t>;
ByteVector decrement(ByteVector bytes) {
std::transform(bytes.begin(), bytes.end(), bytes.begin(), [](auto b) { return b - 1; });
return bytes;
}
} // namespace
TEST(Future, Chain) {
std::packaged_task<const char*()> fetch_string([] { return "ifmmp-"; });
std::packaged_task<ByteVector(std::string)> append_string([](std::string str) {
str += "!xpsme";
return ByteVector{str.begin(), str.end()};
});
std::packaged_task<std::future<ByteVector>(ByteVector)> decrement_bytes(
[](ByteVector bytes) { return ftl::defer(decrement, std::move(bytes)); });
auto fetch = fetch_string.get_future();
std::thread fetch_thread(std::move(fetch_string));
std::thread append_thread, decrement_thread;
EXPECT_EQ(
"hello, world",
ftl::chain(std::move(fetch))
.then([](const char* str) { return std::string(str); })
.then([&](std::string str) {
auto append = append_string.get_future();
append_thread = std::thread(std::move(append_string), std::move(str));
return append;
})
.then([&](ByteVector bytes) {
auto decrement = decrement_bytes.get_future();
decrement_thread = std::thread(std::move(decrement_bytes), std::move(bytes));
return decrement;
})
.then([](std::future<ByteVector> bytes) { return bytes; })
.then([](const ByteVector& bytes) { return std::string(bytes.begin(), bytes.end()); })
.get());
fetch_thread.join();
append_thread.join();
decrement_thread.join();
}
} // namespace android::test
|
