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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
#include <kapi/devices.hpp>
#include <kstd/memory.hpp>
#include <catch2/catch_test_macros.hpp>
namespace
{
struct probe_device
{
constexpr auto static id = kapi::devices::interface{"probe"};
virtual ~probe_device() = default;
[[nodiscard]] auto virtual get_value() const noexcept -> int = 0;
};
struct const_device
{
constexpr auto static id = kapi::devices::interface{"flip"};
virtual ~const_device() = default;
[[nodiscard]] auto get_constant() const noexcept -> int
{
return 0;
}
};
struct test_device final : kapi::devices::device, probe_device
{
explicit test_device(int value, const_device & const_device)
: device{"probeable"}
, m_value{value}
, m_const_device{&const_device}
{}
[[nodiscard]] constexpr auto get_value() const noexcept -> int override
{
return m_value;
}
auto query_interface(kapi::devices::interface interface) -> void * override
{
if (interface == probe_device::id)
{
return static_cast<probe_device *>(this);
}
if (interface == const_device::id)
{
return m_const_device;
}
return kapi::devices::device::query_interface(interface);
}
private:
int m_value;
const_device * m_const_device;
};
} // namespace
SCENARIO("Publishing and finding a device", "[kapi][devices][interface_registry]")
{
GIVEN("An empty registry, a device, and an interface the device implements by inheritance")
{
auto registry = kapi::devices::interface_registry{};
auto free_standing_interface = const_device{};
auto device = kstd::make_shared<test_device>(128, free_standing_interface);
THEN("Publishing an interface without a name fails")
{
REQUIRE_FALSE(registry.publish<probe_device>(device, ""));
}
WHEN("publishing the interface for the device")
{
CHECK(device->is_a<probe_device>());
CHECK(device->is_a<const_device>());
auto published = registry.publish(device, "probe0", device->as<probe_device>());
THEN("publishing is successful")
{
REQUIRE(published);
}
THEN("publishing the same device and interface with a different name fails")
{
REQUIRE_FALSE(registry.publish(device, "probe1", device->as<probe_device>()));
}
THEN("publishing a second interface for the same device succeeds")
{
REQUIRE(registry.publish<const_device>(device, "probe0"));
}
THEN("publishing a free standing second interface for the same device succeeds")
{
REQUIRE(registry.publish(device, "probe0", &free_standing_interface));
}
AND_WHEN("getting all devices implementing that interface")
{
auto probeable_devices = registry.all(probe_device::id);
THEN("there is exactly one such device")
{
REQUIRE(probeable_devices.size() == 1);
}
THEN("the name of the device is 'probe0'")
{
REQUIRE(probeable_devices[0].name() == "probe0");
}
THEN("the returned device pointer is valid")
{
REQUIRE(probeable_devices[0].device());
}
THEN("the returned implementation equals the result of device::as")
{
REQUIRE(probeable_devices[0].implementation() == device->as<probe_device>());
}
THEN("the interface provided function can be invoked")
{
auto implementation = probeable_devices[0].as<probe_device>();
REQUIRE(implementation->get_value() == device->get_value());
}
}
THEN("find finds the published capability by name")
{
REQUIRE(registry.resolve<probe_device>("probe0"));
}
THEN("find for an unpublished capability does not find a device")
{
REQUIRE_FALSE(registry.resolve<const_device>("probe0"));
}
THEN("find for an unpublished device does not find a device")
{
REQUIRE_FALSE(registry.resolve<probe_device>("probe1"));
}
THEN("withdrawing an interface for a device removes it from the registry")
{
registry.unpublish(*device, probe_device::id);
REQUIRE_FALSE(registry.resolve<probe_device>("probe0"));
}
}
WHEN("the device is destroyed without withdrawing it")
{
CHECK(registry.publish(device, "probe0", device->as<probe_device>()));
device.reset();
THEN("querying all does no longer report it")
{
REQUIRE(registry.all(probe_device::id).empty());
}
THEN("find() no longer finds it")
{
REQUIRE_FALSE(registry.resolve<probe_device>("probe0"));
}
}
}
GIVEN("no device has ever been published")
{
auto registry = kapi::devices::interface_registry{};
THEN("all() returns an empty vector")
{
REQUIRE(registry.all(probe_device::id).empty());
}
}
GIVEN("a null device")
{
auto registry = kapi::devices::interface_registry{};
auto device = kstd::shared_ptr<kapi::devices::device>{};
auto interface = const_device{};
THEN("publishing the interface for the device fails")
{
REQUIRE_FALSE(registry.publish(device, "probe0", &interface));
}
}
}
|
