aboutsummaryrefslogtreecommitdiff
path: root/quantum/serial_link/tests/byte_stuffer_tests.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'quantum/serial_link/tests/byte_stuffer_tests.cpp')
-rw-r--r--quantum/serial_link/tests/byte_stuffer_tests.cpp450
1 files changed, 0 insertions, 450 deletions
diff --git a/quantum/serial_link/tests/byte_stuffer_tests.cpp b/quantum/serial_link/tests/byte_stuffer_tests.cpp
deleted file mode 100644
index 9e4e1768f..000000000
--- a/quantum/serial_link/tests/byte_stuffer_tests.cpp
+++ /dev/null
@@ -1,450 +0,0 @@
1/*
2The MIT License (MIT)
3
4Copyright (c) 2016 Fred Sundvik
5
6Permission is hereby granted, free of charge, to any person obtaining a copy
7of this software and associated documentation files (the "Software"), to deal
8in the Software without restriction, including without limitation the rights
9to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10copies of the Software, and to permit persons to whom the Software is
11furnished to do so, subject to the following conditions:
12
13The above copyright notice and this permission notice shall be included in all
14copies or substantial portions of the Software.
15
16THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22SOFTWARE.
23*/
24
25#include "gtest/gtest.h"
26#include "gmock/gmock.h"
27#include <vector>
28#include <algorithm>
29extern "C" {
30#include "serial_link/protocol/byte_stuffer.h"
31#include "serial_link/protocol/frame_validator.h"
32#include "serial_link/protocol/physical.h"
33}
34
35using testing::_;
36using testing::Args;
37using testing::ElementsAreArray;
38
39class ByteStuffer : public ::testing::Test {
40 public:
41 ByteStuffer() {
42 Instance = this;
43 init_byte_stuffer();
44 }
45
46 ~ByteStuffer() { Instance = nullptr; }
47
48 MOCK_METHOD3(validator_recv_frame, void(uint8_t link, uint8_t* data, uint16_t size));
49
50 void send_data(uint8_t link, const uint8_t* data, uint16_t size) { std::copy(data, data + size, std::back_inserter(sent_data)); }
51 std::vector<uint8_t> sent_data;
52
53 static ByteStuffer* Instance;
54};
55
56ByteStuffer* ByteStuffer::Instance = nullptr;
57
58extern "C" {
59void validator_recv_frame(uint8_t link, uint8_t* data, uint16_t size) { ByteStuffer::Instance->validator_recv_frame(link, data, size); }
60
61void send_data(uint8_t link, const uint8_t* data, uint16_t size) { ByteStuffer::Instance->send_data(link, data, size); }
62}
63
64TEST_F(ByteStuffer, receives_no_frame_for_a_single_zero_byte) {
65 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0);
66 byte_stuffer_recv_byte(0, 0);
67}
68
69TEST_F(ByteStuffer, receives_no_frame_for_a_single_FF_byte) {
70 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0);
71 byte_stuffer_recv_byte(0, 0xFF);
72}
73
74TEST_F(ByteStuffer, receives_no_frame_for_a_single_random_byte) {
75 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0);
76 byte_stuffer_recv_byte(0, 0x4A);
77}
78
79TEST_F(ByteStuffer, receives_no_frame_for_a_zero_length_frame) {
80 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0);
81 byte_stuffer_recv_byte(0, 1);
82 byte_stuffer_recv_byte(0, 0);
83}
84
85TEST_F(ByteStuffer, receives_single_byte_valid_frame) {
86 uint8_t expected[] = {0x37};
87 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
88 byte_stuffer_recv_byte(0, 2);
89 byte_stuffer_recv_byte(0, 0x37);
90 byte_stuffer_recv_byte(0, 0);
91}
92TEST_F(ByteStuffer, receives_three_bytes_valid_frame) {
93 uint8_t expected[] = {0x37, 0x99, 0xFF};
94 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
95 byte_stuffer_recv_byte(0, 4);
96 byte_stuffer_recv_byte(0, 0x37);
97 byte_stuffer_recv_byte(0, 0x99);
98 byte_stuffer_recv_byte(0, 0xFF);
99 byte_stuffer_recv_byte(0, 0);
100}
101
102TEST_F(ByteStuffer, receives_single_zero_valid_frame) {
103 uint8_t expected[] = {0};
104 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
105 byte_stuffer_recv_byte(0, 1);
106 byte_stuffer_recv_byte(0, 1);
107 byte_stuffer_recv_byte(0, 0);
108}
109
110TEST_F(ByteStuffer, receives_valid_frame_with_zeroes) {
111 uint8_t expected[] = {5, 0, 3, 0};
112 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
113 byte_stuffer_recv_byte(0, 2);
114 byte_stuffer_recv_byte(0, 5);
115 byte_stuffer_recv_byte(0, 2);
116 byte_stuffer_recv_byte(0, 3);
117 byte_stuffer_recv_byte(0, 1);
118 byte_stuffer_recv_byte(0, 0);
119}
120
121TEST_F(ByteStuffer, receives_two_valid_frames) {
122 uint8_t expected1[] = {5, 0};
123 uint8_t expected2[] = {3};
124 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected1)));
125 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected2)));
126 byte_stuffer_recv_byte(1, 2);
127 byte_stuffer_recv_byte(1, 5);
128 byte_stuffer_recv_byte(1, 1);
129 byte_stuffer_recv_byte(1, 0);
130 byte_stuffer_recv_byte(1, 2);
131 byte_stuffer_recv_byte(1, 3);
132 byte_stuffer_recv_byte(1, 0);
133}
134
135TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_zero) {
136 uint8_t expected[] = {5, 7};
137 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
138 byte_stuffer_recv_byte(1, 3);
139 byte_stuffer_recv_byte(1, 1);
140 byte_stuffer_recv_byte(1, 0);
141 byte_stuffer_recv_byte(1, 3);
142 byte_stuffer_recv_byte(1, 5);
143 byte_stuffer_recv_byte(1, 7);
144 byte_stuffer_recv_byte(1, 0);
145}
146
147TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_non_zero) {
148 uint8_t expected[] = {5, 7};
149 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
150 byte_stuffer_recv_byte(0, 2);
151 byte_stuffer_recv_byte(0, 9);
152 byte_stuffer_recv_byte(0, 4); // This should have been zero
153 byte_stuffer_recv_byte(0, 0);
154 byte_stuffer_recv_byte(0, 3);
155 byte_stuffer_recv_byte(0, 5);
156 byte_stuffer_recv_byte(0, 7);
157 byte_stuffer_recv_byte(0, 0);
158}
159
160TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_and_then_end_of_frame) {
161 uint8_t expected[254];
162 int i;
163 for (i = 0; i < 254; i++) {
164 expected[i] = i + 1;
165 }
166 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
167 byte_stuffer_recv_byte(0, 0xFF);
168 for (i = 0; i < 254; i++) {
169 byte_stuffer_recv_byte(0, i + 1);
170 }
171 byte_stuffer_recv_byte(0, 0);
172}
173
174TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_non_zero) {
175 uint8_t expected[255];
176 int i;
177 for (i = 0; i < 254; i++) {
178 expected[i] = i + 1;
179 }
180 expected[254] = 7;
181 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
182 byte_stuffer_recv_byte(0, 0xFF);
183 for (i = 0; i < 254; i++) {
184 byte_stuffer_recv_byte(0, i + 1);
185 }
186 byte_stuffer_recv_byte(0, 2);
187 byte_stuffer_recv_byte(0, 7);
188 byte_stuffer_recv_byte(0, 0);
189}
190
191TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_zero) {
192 uint8_t expected[255];
193 int i;
194 for (i = 0; i < 254; i++) {
195 expected[i] = i + 1;
196 }
197 expected[254] = 0;
198 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
199 byte_stuffer_recv_byte(0, 0xFF);
200 for (i = 0; i < 254; i++) {
201 byte_stuffer_recv_byte(0, i + 1);
202 }
203 byte_stuffer_recv_byte(0, 1);
204 byte_stuffer_recv_byte(0, 1);
205 byte_stuffer_recv_byte(0, 0);
206}
207
208TEST_F(ByteStuffer, receives_two_long_frames_and_some_more) {
209 uint8_t expected[515];
210 int i;
211 int j;
212 for (j = 0; j < 2; j++) {
213 for (i = 0; i < 254; i++) {
214 expected[i + 254 * j] = i + 1;
215 }
216 }
217 for (i = 0; i < 7; i++) {
218 expected[254 * 2 + i] = i + 1;
219 }
220 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
221 byte_stuffer_recv_byte(0, 0xFF);
222 for (i = 0; i < 254; i++) {
223 byte_stuffer_recv_byte(0, i + 1);
224 }
225 byte_stuffer_recv_byte(0, 0xFF);
226 for (i = 0; i < 254; i++) {
227 byte_stuffer_recv_byte(0, i + 1);
228 }
229 byte_stuffer_recv_byte(0, 8);
230 byte_stuffer_recv_byte(0, 1);
231 byte_stuffer_recv_byte(0, 2);
232 byte_stuffer_recv_byte(0, 3);
233 byte_stuffer_recv_byte(0, 4);
234 byte_stuffer_recv_byte(0, 5);
235 byte_stuffer_recv_byte(0, 6);
236 byte_stuffer_recv_byte(0, 7);
237 byte_stuffer_recv_byte(0, 0);
238}
239
240TEST_F(ByteStuffer, receives_an_all_zeros_frame_that_is_maximum_size) {
241 uint8_t expected[MAX_FRAME_SIZE] = {};
242 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
243 int i;
244 byte_stuffer_recv_byte(0, 1);
245 for (i = 0; i < MAX_FRAME_SIZE; i++) {
246 byte_stuffer_recv_byte(0, 1);
247 }
248 byte_stuffer_recv_byte(0, 0);
249}
250
251TEST_F(ByteStuffer, doesnt_recv_a_frame_thats_too_long_all_zeroes) {
252 uint8_t expected[1] = {0};
253 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).Times(0);
254 int i;
255 byte_stuffer_recv_byte(0, 1);
256 for (i = 0; i < MAX_FRAME_SIZE; i++) {
257 byte_stuffer_recv_byte(0, 1);
258 }
259 byte_stuffer_recv_byte(0, 1);
260 byte_stuffer_recv_byte(0, 0);
261}
262
263TEST_F(ByteStuffer, received_frame_is_aborted_when_its_too_long) {
264 uint8_t expected[1] = {1};
265 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(expected)));
266 int i;
267 byte_stuffer_recv_byte(0, 1);
268 for (i = 0; i < MAX_FRAME_SIZE; i++) {
269 byte_stuffer_recv_byte(0, 1);
270 }
271 byte_stuffer_recv_byte(0, 2);
272 byte_stuffer_recv_byte(0, 1);
273 byte_stuffer_recv_byte(0, 0);
274}
275
276TEST_F(ByteStuffer, does_nothing_when_sending_zero_size_frame) {
277 EXPECT_EQ(sent_data.size(), 0);
278 byte_stuffer_send_frame(0, NULL, 0);
279}
280
281TEST_F(ByteStuffer, send_one_byte_frame) {
282 uint8_t data[] = {5};
283 byte_stuffer_send_frame(1, data, 1);
284 uint8_t expected[] = {2, 5, 0};
285 EXPECT_THAT(sent_data, ElementsAreArray(expected));
286}
287
288TEST_F(ByteStuffer, sends_two_byte_frame) {
289 uint8_t data[] = {5, 0x77};
290 byte_stuffer_send_frame(0, data, 2);
291 uint8_t expected[] = {3, 5, 0x77, 0};
292 EXPECT_THAT(sent_data, ElementsAreArray(expected));
293}
294
295TEST_F(ByteStuffer, sends_one_byte_frame_with_zero) {
296 uint8_t data[] = {0};
297 byte_stuffer_send_frame(0, data, 1);
298 uint8_t expected[] = {1, 1, 0};
299 EXPECT_THAT(sent_data, ElementsAreArray(expected));
300}
301
302TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_zero) {
303 uint8_t data[] = {0, 9};
304 byte_stuffer_send_frame(1, data, 2);
305 uint8_t expected[] = {1, 2, 9, 0};
306 EXPECT_THAT(sent_data, ElementsAreArray(expected));
307}
308
309TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_non_zero) {
310 uint8_t data[] = {9, 0};
311 byte_stuffer_send_frame(1, data, 2);
312 uint8_t expected[] = {2, 9, 1, 0};
313 EXPECT_THAT(sent_data, ElementsAreArray(expected));
314}
315
316TEST_F(ByteStuffer, sends_three_byte_frame_zero_in_the_middle) {
317 uint8_t data[] = {9, 0, 0x68};
318 byte_stuffer_send_frame(0, data, 3);
319 uint8_t expected[] = {2, 9, 2, 0x68, 0};
320 EXPECT_THAT(sent_data, ElementsAreArray(expected));
321}
322
323TEST_F(ByteStuffer, sends_three_byte_frame_data_in_the_middle) {
324 uint8_t data[] = {0, 0x55, 0};
325 byte_stuffer_send_frame(0, data, 3);
326 uint8_t expected[] = {1, 2, 0x55, 1, 0};
327 EXPECT_THAT(sent_data, ElementsAreArray(expected));
328}
329
330TEST_F(ByteStuffer, sends_three_byte_frame_with_all_zeroes) {
331 uint8_t data[] = {0, 0, 0};
332 byte_stuffer_send_frame(0, data, 3);
333 uint8_t expected[] = {1, 1, 1, 1, 0};
334 EXPECT_THAT(sent_data, ElementsAreArray(expected));
335}
336
337TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes) {
338 uint8_t data[254];
339 int i;
340 for (i = 0; i < 254; i++) {
341 data[i] = i + 1;
342 }
343 byte_stuffer_send_frame(0, data, 254);
344 uint8_t expected[256];
345 expected[0] = 0xFF;
346 for (i = 1; i < 255; i++) {
347 expected[i] = i;
348 }
349 expected[255] = 0;
350 EXPECT_THAT(sent_data, ElementsAreArray(expected));
351}
352
353TEST_F(ByteStuffer, sends_frame_with_255_non_zeroes) {
354 uint8_t data[255];
355 int i;
356 for (i = 0; i < 255; i++) {
357 data[i] = i + 1;
358 }
359 byte_stuffer_send_frame(0, data, 255);
360 uint8_t expected[258];
361 expected[0] = 0xFF;
362 for (i = 1; i < 255; i++) {
363 expected[i] = i;
364 }
365 expected[255] = 2;
366 expected[256] = 255;
367 expected[257] = 0;
368 EXPECT_THAT(sent_data, ElementsAreArray(expected));
369}
370
371TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes_followed_by_zero) {
372 uint8_t data[255];
373 int i;
374 for (i = 0; i < 254; i++) {
375 data[i] = i + 1;
376 }
377 data[254] = 0;
378 byte_stuffer_send_frame(0, data, 255);
379 uint8_t expected[258];
380 expected[0] = 0xFF;
381 for (i = 1; i < 255; i++) {
382 expected[i] = i;
383 }
384 expected[255] = 1;
385 expected[256] = 1;
386 expected[257] = 0;
387 EXPECT_THAT(sent_data, ElementsAreArray(expected));
388}
389
390TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet) {
391 uint8_t original_data[] = {1, 2, 3};
392 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
393 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data)));
394 int i;
395 for (auto& d : sent_data) {
396 byte_stuffer_recv_byte(1, d);
397 }
398}
399
400TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet_with_zeros) {
401 uint8_t original_data[] = {1, 0, 3, 0, 0, 9};
402 byte_stuffer_send_frame(1, original_data, sizeof(original_data));
403 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data)));
404 int i;
405 for (auto& d : sent_data) {
406 byte_stuffer_recv_byte(1, d);
407 }
408}
409
410TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes) {
411 uint8_t original_data[254];
412 int i;
413 for (i = 0; i < 254; i++) {
414 original_data[i] = i + 1;
415 }
416 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
417 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data)));
418 for (auto& d : sent_data) {
419 byte_stuffer_recv_byte(1, d);
420 }
421}
422
423TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_256_bytes) {
424 uint8_t original_data[256];
425 int i;
426 for (i = 0; i < 254; i++) {
427 original_data[i] = i + 1;
428 }
429 original_data[254] = 22;
430 original_data[255] = 23;
431 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
432 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data)));
433 for (auto& d : sent_data) {
434 byte_stuffer_recv_byte(1, d);
435 }
436}
437
438TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes_and_then_zero) {
439 uint8_t original_data[255];
440 int i;
441 for (i = 0; i < 254; i++) {
442 original_data[i] = i + 1;
443 }
444 original_data[254] = 0;
445 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
446 EXPECT_CALL(*this, validator_recv_frame(_, _, _)).With(Args<1, 2>(ElementsAreArray(original_data)));
447 for (auto& d : sent_data) {
448 byte_stuffer_recv_byte(1, d);
449 }
450}