IRSOL
C++ code implementing socket server for interacting with Baumer camera.
test_serializer.cpp
Go to the documentation of this file.
1#include "irsol/protocol/message.hpp"
2#include "irsol/protocol/serialization/serializer.hpp"
3
4#include <catch2/catch_all.hpp>
5#include <utility>
6
7TEST_CASE("Serializer::message_termination", "[Protocol][Protocol::Serialization]")
8{
9 CHECK(std::string(irsol::protocol::Serializer::message_termination) == "\n");
10}
11TEST_CASE("Serializer::serializeValue<direct>()", "[Protocol][Protocol::Serialization]")
12{
13 {
14 // From an integer
15 int value = GENERATE(1, 2, 3, 4, 5);
16 std::string expected = std::to_string(value);
17 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(value));
18 CHECK(serialized == expected);
19 }
20 {
21 // From a double
22 double value = GENERATE(1.0, 2.5, 3.14, 4.2, 5.0, -31.4, 0.0);
23 std::string expected = std::to_string(value);
24 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(value));
25 CHECK(serialized == expected);
26 }
27 {
28 // From a string
29 std::string value = GENERATE("", "hello", "world", "test", "12345");
30 std::string expected = "{" + value + "}";
31 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(value));
32 CHECK(serialized == expected);
33 }
34}
35
36TEST_CASE("Serializer::serializeValue<variant>()", "[Protocol][Protocol::Serialization]")
37{
38 {
39 // From an integer
40 int value = GENERATE(1, 2, 3, 4, 5);
41 irsol::types::protocol_value_t variantValue(value);
42 std::string expected = std::to_string(value);
43 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(variantValue));
44 CHECK(serialized == expected);
45 }
46 {
47 // From a double
48 double value = GENERATE(1.0, 2.5, 3.14, 4.2, 5.0, -31.4, 0.0);
49 irsol::types::protocol_value_t variantValue(value);
50 std::string expected = std::to_string(value);
51 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(variantValue));
52 CHECK(serialized == expected);
53 }
54 {
55 // From a string
56 auto [value, expected] = GENERATE(
57 std::make_pair("", "{}"),
58 std::make_pair("hello", "{hello}"),
59 std::make_pair("world", "{world}"),
60 std::make_pair("test", "{test}"),
61 std::make_pair("12345", "{12345}"));
62 irsol::types::protocol_value_t variantValue(value);
63 std::string serialized = irsol::protocol::Serializer::serializeValue(std::move(variantValue));
64 CHECK(serialized == expected);
65 }
66}
67
68TEST_CASE("Serializer::serialize<direct>(Success)", "[Protocol][Protocol::Serialization]")
69{
70 {
71 // From a successful Assignment
72 auto identifier =
73 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
74 auto value = GENERATE(
75 irsol::types::protocol_value_t{42},
76 irsol::types::protocol_value_t{3.15},
77 irsol::types::protocol_value_t{"my string"});
78
79 irsol::protocol::Assignment assignment{identifier, value};
80 irsol::protocol::Success success = irsol::protocol::Success::from(assignment);
81
82 std::string expectedHeader =
83 std::string(identifier) + "=" +
84 irsol::protocol::Serializer::serializeValue(irsol::types::protocol_value_t(value)) +
85 irsol::protocol::Serializer::message_termination;
86 auto serialized = irsol::protocol::Serializer::serialize(std::move(success));
87 CHECK(serialized.header == expectedHeader);
88 CHECK_FALSE(serialized.hasPayload());
89 CHECK(serialized.payloadSize() == 0);
90 }
91 {
92 // From a successful Inquiry
93 auto identifier =
94 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
95 auto inquery_result = GENERATE(
96 irsol::types::protocol_value_t{42},
97 irsol::types::protocol_value_t{3.15},
98 irsol::types::protocol_value_t{"my string"});
99 irsol::protocol::Inquiry inquiry{identifier};
100 auto success = irsol::protocol::Success::from(inquiry, inquery_result);
101
102 std::string expectedHeader =
103 std::string(identifier) + "=" +
104 irsol::protocol::Serializer::serializeValue(irsol::types::protocol_value_t(inquery_result)) +
105 irsol::protocol::Serializer::message_termination;
106 auto serialized = irsol::protocol::Serializer::serialize(std::move(success));
107 CHECK(serialized.header == expectedHeader);
108 CHECK_FALSE(serialized.hasPayload());
109 CHECK(serialized.payloadSize() == 0);
110 }
111 {
112 // From a successful Command
113 auto identifier = GENERATE("x", "it", "long_identifier");
114 irsol::protocol::Command command{identifier};
115 auto success = irsol::protocol::Success::from(command);
116
117 std::string expectedHeader = std::string(identifier) + ";\n";
118 auto serialized = irsol::protocol::Serializer::serialize(std::move(success));
119 CHECK(serialized.header == expectedHeader);
120 CHECK_FALSE(serialized.hasPayload());
121 CHECK(serialized.payloadSize() == 0);
122 }
123}
124
125TEST_CASE("Serializer::serialize<variant>(Success)", "[Protocol][Protocol::Serialization]")
126{
127 {
128 // From a successful Assignment
129 auto identifier =
130 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
131 auto value = GENERATE(
132 irsol::types::protocol_value_t{42},
133 irsol::types::protocol_value_t{3.15},
134 irsol::types::protocol_value_t{"my string"});
135 irsol::protocol::Assignment assignment{identifier, value};
136 auto success = irsol::protocol::Success::from(assignment);
137 auto successVariant = irsol::protocol::OutMessage(success);
138
139 std::string expectedHeader =
140 std::string(identifier) + "=" +
141 irsol::protocol::Serializer::serializeValue(irsol::types::protocol_value_t(value)) +
142 irsol::protocol::Serializer::message_termination;
143 auto serialized = irsol::protocol::Serializer::serialize(std::move(successVariant));
144 CHECK(serialized.header == expectedHeader);
145 CHECK_FALSE(serialized.hasPayload());
146 CHECK(serialized.payloadSize() == 0);
147 }
148 {
149 // From a successful Inquiry
150 auto identifier =
151 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
152 auto inquery_result = GENERATE(
153 irsol::types::protocol_value_t{42},
154 irsol::types::protocol_value_t{3.15},
155 irsol::types::protocol_value_t{"my string"});
156 irsol::protocol::Inquiry inquiry{identifier};
157 auto success = irsol::protocol::Success::from(inquiry, inquery_result);
158 auto successVariant = irsol::protocol::OutMessage(success);
159
160 std::string expectedHeader =
161 std::string(identifier) + "=" +
162 irsol::protocol::Serializer::serializeValue(irsol::types::protocol_value_t(inquery_result)) +
163 irsol::protocol::Serializer::message_termination;
164 auto serialized = irsol::protocol::Serializer::serialize(std::move(successVariant));
165 CHECK(serialized.header == expectedHeader);
166 CHECK_FALSE(serialized.hasPayload());
167 CHECK(serialized.payloadSize() == 0);
168 }
169 {
170 // From a successful Command
171 auto identifier = GENERATE("x", "it", "long_identifier");
172 irsol::protocol::Command command{identifier};
173 auto success = irsol::protocol::Success::from(command);
174 auto successVariant = irsol::protocol::OutMessage(success);
175
176 std::string expectedHeader = std::string(identifier) + ";\n";
177 auto serialized = irsol::protocol::Serializer::serialize(std::move(successVariant));
178 CHECK(serialized.header == expectedHeader);
179 CHECK_FALSE(serialized.hasPayload());
180 CHECK(serialized.payloadSize() == 0);
181 }
182}
183
184TEST_CASE("Serializer::serialize<direct>(Error)", "[Protocol][Protocol::Serialization]")
185{
186 auto description = GENERATE("", "hello world", "error description");
187 {
188 // From an erroneous Assignment
189 auto identifier =
190 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
191 auto value = GENERATE(
192 irsol::types::protocol_value_t{42},
193 irsol::types::protocol_value_t{3.15},
194 irsol::types::protocol_value_t{"my string"});
195
196 irsol::protocol::Assignment assignment{identifier, value};
197 auto error = irsol::protocol::Error::from(assignment, description);
198
199 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
200 irsol::protocol::Serializer::message_termination;
201 auto serialized = irsol::protocol::Serializer::serialize(std::move(error));
202 CHECK(serialized.header == expectedHeader);
203 CHECK_FALSE(serialized.hasPayload());
204 CHECK(serialized.payloadSize() == 0);
205 }
206 {
207 // From an erroneous Inquiry
208 auto identifier =
209 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
210 irsol::protocol::Inquiry inquiry{identifier};
211 auto error = irsol::protocol::Error::from(inquiry, description);
212
213 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
214 irsol::protocol::Serializer::message_termination;
215 auto serialized = irsol::protocol::Serializer::serialize(std::move(error));
216 CHECK(serialized.header == expectedHeader);
217 CHECK_FALSE(serialized.hasPayload());
218 CHECK(serialized.payloadSize() == 0);
219 }
220 {
221 // From an erroneous Command
222 auto identifier = GENERATE("x", "it", "long_identifier");
223 irsol::protocol::Command command{identifier};
224 auto error = irsol::protocol::Error::from(command, description);
225
226 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
227 irsol::protocol::Serializer::message_termination;
228 auto serialized = irsol::protocol::Serializer::serialize(std::move(error));
229 CHECK(serialized.header == expectedHeader);
230 CHECK_FALSE(serialized.hasPayload());
231 CHECK(serialized.payloadSize() == 0);
232 }
233}
234TEST_CASE("Serializer::serialize<variant>(Error)", "[Protocol][Protocol::Serialization]")
235{
236 auto description = GENERATE("", "hello world", "error description");
237 {
238 // From an erroneous Assignment
239 auto identifier =
240 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
241 auto value = GENERATE(
242 irsol::types::protocol_value_t{42},
243 irsol::types::protocol_value_t{3.15},
244 irsol::types::protocol_value_t{"my string"});
245
246 irsol::protocol::Assignment assignment{identifier, value};
247 auto error = irsol::protocol::Error::from(assignment, description);
248 auto errorVariant = irsol::protocol::OutMessage(error);
249
250 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
251 irsol::protocol::Serializer::message_termination;
252 auto serialized = irsol::protocol::Serializer::serialize(std::move(errorVariant));
253 CHECK(serialized.header == expectedHeader);
254 CHECK_FALSE(serialized.hasPayload());
255 CHECK(serialized.payloadSize() == 0);
256 }
257 {
258 // From an erroneous Inquiry
259 auto identifier =
260 GENERATE("x", "it", "long_identifier", "sequence_identifier[5]", "nested_identifier[3][2]");
261 irsol::protocol::Inquiry inquiry{identifier};
262 auto error = irsol::protocol::Error::from(inquiry, description);
263 auto errorVariant = irsol::protocol::OutMessage(error);
264
265 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
266 irsol::protocol::Serializer::message_termination;
267 auto serialized = irsol::protocol::Serializer::serialize(std::move(errorVariant));
268 CHECK(serialized.header == expectedHeader);
269 CHECK_FALSE(serialized.hasPayload());
270 CHECK(serialized.payloadSize() == 0);
271 }
272 {
273 // From an erroneous Command
274 auto identifier = GENERATE("x", "it", "long_identifier");
275 irsol::protocol::Command command{identifier};
276 auto error = irsol::protocol::Error::from(command, description);
277 auto errorVariant = irsol::protocol::OutMessage(error);
278
279 std::string expectedHeader = std::string(identifier) + ": Error: " + description +
280 irsol::protocol::Serializer::message_termination;
281 auto serialized = irsol::protocol::Serializer::serialize(std::move(errorVariant));
282 CHECK(serialized.header == expectedHeader);
283 CHECK_FALSE(serialized.hasPayload());
284 CHECK(serialized.payloadSize() == 0);
285 }
286}
irsol::protocol::Serializer::message_termination
static constexpr const char * message_termination
Message line termination sequence (newline character) used to "close" a serialized message.
Definition serializer.hpp:65
irsol::protocol::Serializer::serializeValue
static std::string serializeValue(irsol::types::protocol_value_t &&value)
Serialize a protocol primitive value to a string.
Definition serializer.cpp:26
irsol::protocol::Serializer::serialize
static internal::SerializedMessage serialize(OutMessage &&msg)
Serialize an irsol::protocol::OutMessage variant into a serialized protocol message.
Definition serializer.cpp:14
irsol::protocol::OutMessage
std::variant< Success, BinaryDataBuffer, ImageBinaryData, ColorImageBinaryData, Error > OutMessage
Variant type representing any outgoing message.
Definition variants.hpp:149
irsol::types::protocol_value_t
std::variant< int, double, std::string > protocol_value_t
Variant type representing protocol values that can be one of several types.
Definition types.hpp:150
serializer.hpp
Serialization utilities for protocol messages and primitive values.
irsol::protocol::Assignment
Represents an assignment operation in the protocol.
Definition assignment.hpp:32
irsol::protocol::Command
Represents a command invocation in the protocol.
Definition command.hpp:33
irsol::protocol::Error::from
static Error from(const T &msg, const std::string &description)
Creates an error from a specific incoming message type.
Definition error.hpp:63
irsol::protocol::Inquiry
Represents a value inquiry in the protocol.
Definition inquiry.hpp:32
irsol::protocol::Success
Represents a success response message from the server.
Definition success.hpp:39
irsol::protocol::Success::from
static Success from(const Assignment &msg, std::optional< irsol::types::protocol_value_t > overrideValue=std::nullopt)
Creates a success message from an Assignment.
Definition success.hpp:75
value
auto value
Definition test_assignment.cpp:31
CHECK
CHECK(m.identifier==identifier)
CHECK_FALSE
CHECK_FALSE(m.hasDouble())
description
auto description
Definition test_error.cpp:10
assignment
irsol::protocol::Assignment assignment
Definition test_error.cpp:16
TEST_CASE
TEST_CASE("Serializer::message_termination", "[Protocol][Protocol::Serialization]")
Definition test_serializer.cpp:7
expected
std::vector< std::string > expected
Definition test_utils.cpp:44