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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
|
// This file is part of CAF, the C++ Actor Framework. See the file LICENSE in
// the main distribution directory for license terms and copyright or visit
// https://github.com/actor-framework/actor-framework/blob/master/LICENSE.
#define CAF_SUITE scheduled_actor
#include "caf/scheduled_actor.hpp"
#include "core-test.hpp"
using namespace caf;
#define ASSERT_COMPILES(expr, msg) \
static_assert( \
std::is_void_v<decltype(std::declval<scheduled_actor*>()->expr)>, msg);
namespace {
// -- compile-time checks for set_default_handler ------------------------------
struct mutable_default_fn {
skippable_result operator()(message&) {
return {};
}
};
ASSERT_COMPILES(set_default_handler(mutable_default_fn{}),
"set_default_handler must accept mutable function objects");
struct const_default_fn {
skippable_result operator()(message&) const {
return {};
}
};
ASSERT_COMPILES(set_default_handler(const_default_fn{}),
"set_default_handler must accept const function objects");
// -- compile-time checks for set_error_handler --------------------------------
struct mutable_error_fn {
void operator()(error&) {
// nop
}
};
ASSERT_COMPILES(set_error_handler(mutable_error_fn{}),
"set_error_handler must accept mutable function objects");
struct const_error_fn {
void operator()(error&) const {
// nop
}
};
ASSERT_COMPILES(set_error_handler(const_error_fn{}),
"set_error_handler must accept const function objects");
// -- compile-time checks for set_down_handler ---------------------------------
struct mutable_down_fn {
void operator()(down_msg&) {
// nop
}
};
ASSERT_COMPILES(set_down_handler(mutable_down_fn{}),
"set_down_handler must accept mutable function objects");
struct const_down_fn {
void operator()(down_msg&) const {
// nop
}
};
ASSERT_COMPILES(set_down_handler(const_down_fn{}),
"set_down_handler must accept const function objects");
// -- compile-time checks for set_node_down_handler ----------------------------
struct mutable_node_down_fn {
void operator()(node_down_msg&) {
// nop
}
};
ASSERT_COMPILES(set_node_down_handler(mutable_node_down_fn{}),
"set_node_down_handler must accept mutable function objects");
struct const_node_down_fn {
void operator()(node_down_msg&) const {
// nop
}
};
ASSERT_COMPILES(set_node_down_handler(const_node_down_fn{}),
"set_node_down_handler must accept const function objects");
// -- compile-time checks for set_exit_handler ---------------------------------
struct mutable_exit_fn {
void operator()(exit_msg&) {
// nop
}
};
ASSERT_COMPILES(set_exit_handler(mutable_exit_fn{}),
"set_exit_handler must accept mutable function objects");
struct const_exit_fn {
void operator()(exit_msg&) const {
// nop
}
};
ASSERT_COMPILES(set_exit_handler(const_exit_fn{}),
"set_exit_handler must accept const function objects");
// -- compile-time checks for set_exception_handler ----------------------------
#ifdef CAF_ENABLE_EXCEPTIONS
struct mutable_exception_fn {
error operator()(std::exception_ptr&) {
return {};
}
};
ASSERT_COMPILES(set_exception_handler(mutable_exception_fn{}),
"set_exception_handler must accept mutable function objects");
struct const_exception_fn {
error operator()(std::exception_ptr&) const {
return {};
}
};
ASSERT_COMPILES(set_exception_handler(const_exception_fn{}),
"set_exception_handler must accept const function objects");
#endif // CAF_ENABLE_EXCEPTIONS
} // namespace
|
