4 Copyright (c) 2016 Fred Sundvik
6 Permission is hereby granted, free of charge, to any person obtaining a copy
7 of this software and associated documentation files (the "Software"), to deal
8 in the Software without restriction, including without limitation the rights
9 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 copies of the Software, and to permit persons to whom the Software is
11 furnished to do so, subject to the following conditions:
13 The above copyright notice and this permission notice shall be included in all
14 copies or substantial portions of the Software.
16 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
25 #include "gtest/gtest.h"
26 #include "gmock/gmock.h"
30 #include "serial_link/protocol/byte_stuffer.h"
31 #include "serial_link/protocol/frame_validator.h"
32 #include "serial_link/protocol/physical.h"
36 using testing::ElementsAreArray;
39 class ByteStuffer : public ::testing::Test{
50 MOCK_METHOD3(validator_recv_frame, void (uint8_t link, uint8_t* data, uint16_t size));
52 void send_data(uint8_t link, const uint8_t* data, uint16_t size) {
53 std::copy(data, data + size, std::back_inserter(sent_data));
55 std::vector<uint8_t> sent_data;
57 static ByteStuffer* Instance;
60 ByteStuffer* ByteStuffer::Instance = nullptr;
63 void validator_recv_frame(uint8_t link, uint8_t* data, uint16_t size) {
64 ByteStuffer::Instance->validator_recv_frame(link, data, size);
67 void send_data(uint8_t link, const uint8_t* data, uint16_t size) {
68 ByteStuffer::Instance->send_data(link, data, size);
72 TEST_F(ByteStuffer, receives_no_frame_for_a_single_zero_byte) {
73 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
75 byte_stuffer_recv_byte(0, 0);
78 TEST_F(ByteStuffer, receives_no_frame_for_a_single_FF_byte) {
79 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
81 byte_stuffer_recv_byte(0, 0xFF);
84 TEST_F(ByteStuffer, receives_no_frame_for_a_single_random_byte) {
85 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
87 byte_stuffer_recv_byte(0, 0x4A);
90 TEST_F(ByteStuffer, receives_no_frame_for_a_zero_length_frame) {
91 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
93 byte_stuffer_recv_byte(0, 1);
94 byte_stuffer_recv_byte(0, 0);
97 TEST_F(ByteStuffer, receives_single_byte_valid_frame) {
98 uint8_t expected[] = {0x37};
99 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
100 .With(Args<1, 2>(ElementsAreArray(expected)));
101 byte_stuffer_recv_byte(0, 2);
102 byte_stuffer_recv_byte(0, 0x37);
103 byte_stuffer_recv_byte(0, 0);
105 TEST_F(ByteStuffer, receives_three_bytes_valid_frame) {
106 uint8_t expected[] = {0x37, 0x99, 0xFF};
107 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
108 .With(Args<1, 2>(ElementsAreArray(expected)));
109 byte_stuffer_recv_byte(0, 4);
110 byte_stuffer_recv_byte(0, 0x37);
111 byte_stuffer_recv_byte(0, 0x99);
112 byte_stuffer_recv_byte(0, 0xFF);
113 byte_stuffer_recv_byte(0, 0);
116 TEST_F(ByteStuffer, receives_single_zero_valid_frame) {
117 uint8_t expected[] = {0};
118 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
119 .With(Args<1, 2>(ElementsAreArray(expected)));
120 byte_stuffer_recv_byte(0, 1);
121 byte_stuffer_recv_byte(0, 1);
122 byte_stuffer_recv_byte(0, 0);
125 TEST_F(ByteStuffer, receives_valid_frame_with_zeroes) {
126 uint8_t expected[] = {5, 0, 3, 0};
127 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
128 .With(Args<1, 2>(ElementsAreArray(expected)));
129 byte_stuffer_recv_byte(0, 2);
130 byte_stuffer_recv_byte(0, 5);
131 byte_stuffer_recv_byte(0, 2);
132 byte_stuffer_recv_byte(0, 3);
133 byte_stuffer_recv_byte(0, 1);
134 byte_stuffer_recv_byte(0, 0);
138 TEST_F(ByteStuffer, receives_two_valid_frames) {
139 uint8_t expected1[] = {5, 0};
140 uint8_t expected2[] = {3};
141 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
142 .With(Args<1, 2>(ElementsAreArray(expected1)));
143 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
144 .With(Args<1, 2>(ElementsAreArray(expected2)));
145 byte_stuffer_recv_byte(1, 2);
146 byte_stuffer_recv_byte(1, 5);
147 byte_stuffer_recv_byte(1, 1);
148 byte_stuffer_recv_byte(1, 0);
149 byte_stuffer_recv_byte(1, 2);
150 byte_stuffer_recv_byte(1, 3);
151 byte_stuffer_recv_byte(1, 0);
154 TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_zero) {
155 uint8_t expected[] = {5, 7};
156 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
157 .With(Args<1, 2>(ElementsAreArray(expected)));
158 byte_stuffer_recv_byte(1, 3);
159 byte_stuffer_recv_byte(1, 1);
160 byte_stuffer_recv_byte(1, 0);
161 byte_stuffer_recv_byte(1, 3);
162 byte_stuffer_recv_byte(1, 5);
163 byte_stuffer_recv_byte(1, 7);
164 byte_stuffer_recv_byte(1, 0);
167 TEST_F(ByteStuffer, receives_valid_frame_after_unexpected_non_zero) {
168 uint8_t expected[] = {5, 7};
169 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
170 .With(Args<1, 2>(ElementsAreArray(expected)));
171 byte_stuffer_recv_byte(0, 2);
172 byte_stuffer_recv_byte(0, 9);
173 byte_stuffer_recv_byte(0, 4); // This should have been zero
174 byte_stuffer_recv_byte(0, 0);
175 byte_stuffer_recv_byte(0, 3);
176 byte_stuffer_recv_byte(0, 5);
177 byte_stuffer_recv_byte(0, 7);
178 byte_stuffer_recv_byte(0, 0);
181 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_and_then_end_of_frame) {
182 uint8_t expected[254];
184 for (i=0;i<254;i++) {
187 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
188 .With(Args<1, 2>(ElementsAreArray(expected)));
189 byte_stuffer_recv_byte(0, 0xFF);
190 for (i=0;i<254;i++) {
191 byte_stuffer_recv_byte(0, i+1);
193 byte_stuffer_recv_byte(0, 0);
196 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_non_zero) {
197 uint8_t expected[255];
199 for (i=0;i<254;i++) {
203 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
204 .With(Args<1, 2>(ElementsAreArray(expected)));
205 byte_stuffer_recv_byte(0, 0xFF);
206 for (i=0;i<254;i++) {
207 byte_stuffer_recv_byte(0, i+1);
209 byte_stuffer_recv_byte(0, 2);
210 byte_stuffer_recv_byte(0, 7);
211 byte_stuffer_recv_byte(0, 0);
214 TEST_F(ByteStuffer, receives_a_valid_frame_with_over254_non_zeroes_next_byte_is_zero) {
215 uint8_t expected[255];
217 for (i=0;i<254;i++) {
221 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
222 .With(Args<1, 2>(ElementsAreArray(expected)));
223 byte_stuffer_recv_byte(0, 0xFF);
224 for (i=0;i<254;i++) {
225 byte_stuffer_recv_byte(0, i+1);
227 byte_stuffer_recv_byte(0, 1);
228 byte_stuffer_recv_byte(0, 1);
229 byte_stuffer_recv_byte(0, 0);
232 TEST_F(ByteStuffer, receives_two_long_frames_and_some_more) {
233 uint8_t expected[515];
237 for (i=0;i<254;i++) {
238 expected[i+254*j] = i + 1;
242 expected[254*2+i] = i + 1;
244 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
245 .With(Args<1, 2>(ElementsAreArray(expected)));
246 byte_stuffer_recv_byte(0, 0xFF);
247 for (i=0;i<254;i++) {
248 byte_stuffer_recv_byte(0, i+1);
250 byte_stuffer_recv_byte(0, 0xFF);
251 for (i=0;i<254;i++) {
252 byte_stuffer_recv_byte(0, i+1);
254 byte_stuffer_recv_byte(0, 8);
255 byte_stuffer_recv_byte(0, 1);
256 byte_stuffer_recv_byte(0, 2);
257 byte_stuffer_recv_byte(0, 3);
258 byte_stuffer_recv_byte(0, 4);
259 byte_stuffer_recv_byte(0, 5);
260 byte_stuffer_recv_byte(0, 6);
261 byte_stuffer_recv_byte(0, 7);
262 byte_stuffer_recv_byte(0, 0);
265 TEST_F(ByteStuffer, receives_an_all_zeros_frame_that_is_maximum_size) {
266 uint8_t expected[MAX_FRAME_SIZE] = {};
267 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
268 .With(Args<1, 2>(ElementsAreArray(expected)));
270 byte_stuffer_recv_byte(0, 1);
271 for(i=0;i<MAX_FRAME_SIZE;i++) {
272 byte_stuffer_recv_byte(0, 1);
274 byte_stuffer_recv_byte(0, 0);
277 TEST_F(ByteStuffer, doesnt_recv_a_frame_thats_too_long_all_zeroes) {
278 uint8_t expected[1] = {0};
279 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
282 byte_stuffer_recv_byte(0, 1);
283 for(i=0;i<MAX_FRAME_SIZE;i++) {
284 byte_stuffer_recv_byte(0, 1);
286 byte_stuffer_recv_byte(0, 1);
287 byte_stuffer_recv_byte(0, 0);
290 TEST_F(ByteStuffer, received_frame_is_aborted_when_its_too_long) {
291 uint8_t expected[1] = {1};
292 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
293 .With(Args<1, 2>(ElementsAreArray(expected)));
295 byte_stuffer_recv_byte(0, 1);
296 for(i=0;i<MAX_FRAME_SIZE;i++) {
297 byte_stuffer_recv_byte(0, 1);
299 byte_stuffer_recv_byte(0, 2);
300 byte_stuffer_recv_byte(0, 1);
301 byte_stuffer_recv_byte(0, 0);
304 TEST_F(ByteStuffer, does_nothing_when_sending_zero_size_frame) {
305 EXPECT_EQ(sent_data.size(), 0);
306 byte_stuffer_send_frame(0, NULL, 0);
309 TEST_F(ByteStuffer, send_one_byte_frame) {
310 uint8_t data[] = {5};
311 byte_stuffer_send_frame(1, data, 1);
312 uint8_t expected[] = {2, 5, 0};
313 EXPECT_THAT(sent_data, ElementsAreArray(expected));
316 TEST_F(ByteStuffer, sends_two_byte_frame) {
317 uint8_t data[] = {5, 0x77};
318 byte_stuffer_send_frame(0, data, 2);
319 uint8_t expected[] = {3, 5, 0x77, 0};
320 EXPECT_THAT(sent_data, ElementsAreArray(expected));
323 TEST_F(ByteStuffer, sends_one_byte_frame_with_zero) {
324 uint8_t data[] = {0};
325 byte_stuffer_send_frame(0, data, 1);
326 uint8_t expected[] = {1, 1, 0};
327 EXPECT_THAT(sent_data, ElementsAreArray(expected));
330 TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_zero) {
331 uint8_t data[] = {0, 9};
332 byte_stuffer_send_frame(1, data, 2);
333 uint8_t expected[] = {1, 2, 9, 0};
334 EXPECT_THAT(sent_data, ElementsAreArray(expected));
337 TEST_F(ByteStuffer, sends_two_byte_frame_starting_with_non_zero) {
338 uint8_t data[] = {9, 0};
339 byte_stuffer_send_frame(1, data, 2);
340 uint8_t expected[] = {2, 9, 1, 0};
341 EXPECT_THAT(sent_data, ElementsAreArray(expected));
344 TEST_F(ByteStuffer, sends_three_byte_frame_zero_in_the_middle) {
345 uint8_t data[] = {9, 0, 0x68};
346 byte_stuffer_send_frame(0, data, 3);
347 uint8_t expected[] = {2, 9, 2, 0x68, 0};
348 EXPECT_THAT(sent_data, ElementsAreArray(expected));
351 TEST_F(ByteStuffer, sends_three_byte_frame_data_in_the_middle) {
352 uint8_t data[] = {0, 0x55, 0};
353 byte_stuffer_send_frame(0, data, 3);
354 uint8_t expected[] = {1, 2, 0x55, 1, 0};
355 EXPECT_THAT(sent_data, ElementsAreArray(expected));
358 TEST_F(ByteStuffer, sends_three_byte_frame_with_all_zeroes) {
359 uint8_t data[] = {0, 0, 0};
360 byte_stuffer_send_frame(0, data, 3);
361 uint8_t expected[] = {1, 1, 1, 1, 0};
362 EXPECT_THAT(sent_data, ElementsAreArray(expected));
365 TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes) {
371 byte_stuffer_send_frame(0, data, 254);
372 uint8_t expected[256];
378 EXPECT_THAT(sent_data, ElementsAreArray(expected));
381 TEST_F(ByteStuffer, sends_frame_with_255_non_zeroes) {
387 byte_stuffer_send_frame(0, data, 255);
388 uint8_t expected[258];
396 EXPECT_THAT(sent_data, ElementsAreArray(expected));
399 TEST_F(ByteStuffer, sends_frame_with_254_non_zeroes_followed_by_zero) {
406 byte_stuffer_send_frame(0, data, 255);
407 uint8_t expected[258];
415 EXPECT_THAT(sent_data, ElementsAreArray(expected));
418 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet) {
419 uint8_t original_data[] = { 1, 2, 3};
420 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
421 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
422 .With(Args<1, 2>(ElementsAreArray(original_data)));
424 for(auto& d : sent_data) {
425 byte_stuffer_recv_byte(1, d);
429 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_small_packet_with_zeros) {
430 uint8_t original_data[] = { 1, 0, 3, 0, 0, 9};
431 byte_stuffer_send_frame(1, original_data, sizeof(original_data));
432 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
433 .With(Args<1, 2>(ElementsAreArray(original_data)));
435 for(auto& d : sent_data) {
436 byte_stuffer_recv_byte(1, d);
440 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes) {
441 uint8_t original_data[254];
444 original_data[i] = i + 1;
446 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
447 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
448 .With(Args<1, 2>(ElementsAreArray(original_data)));
449 for(auto& d : sent_data) {
450 byte_stuffer_recv_byte(1, d);
454 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_256_bytes) {
455 uint8_t original_data[256];
458 original_data[i] = i + 1;
460 original_data[254] = 22;
461 original_data[255] = 23;
462 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
463 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
464 .With(Args<1, 2>(ElementsAreArray(original_data)));
465 for(auto& d : sent_data) {
466 byte_stuffer_recv_byte(1, d);
470 TEST_F(ByteStuffer, sends_and_receives_full_roundtrip_254_bytes_and_then_zero) {
471 uint8_t original_data[255];
474 original_data[i] = i + 1;
476 original_data[254] = 0;
477 byte_stuffer_send_frame(0, original_data, sizeof(original_data));
478 EXPECT_CALL(*this, validator_recv_frame(_, _, _))
479 .With(Args<1, 2>(ElementsAreArray(original_data)));
480 for(auto& d : sent_data) {
481 byte_stuffer_recv_byte(1, d);