diff options
Diffstat (limited to 'quantum/serial_link/tests/byte_stuffer_tests.cpp')
-rw-r--r-- | quantum/serial_link/tests/byte_stuffer_tests.cpp | 450 |
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 | /* | ||
2 | The MIT License (MIT) | ||
3 | |||
4 | Copyright (c) 2016 Fred Sundvik | ||
5 | |||
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: | ||
12 | |||
13 | The above copyright notice and this permission notice shall be included in all | ||
14 | copies or substantial portions of the Software. | ||
15 | |||
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 | ||
22 | SOFTWARE. | ||
23 | */ | ||
24 | |||
25 | #include "gtest/gtest.h" | ||
26 | #include "gmock/gmock.h" | ||
27 | #include <vector> | ||
28 | #include <algorithm> | ||
29 | extern "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 | |||
35 | using testing::_; | ||
36 | using testing::Args; | ||
37 | using testing::ElementsAreArray; | ||
38 | |||
39 | class 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 | |||
56 | ByteStuffer* ByteStuffer::Instance = nullptr; | ||
57 | |||
58 | extern "C" { | ||
59 | void validator_recv_frame(uint8_t link, uint8_t* data, uint16_t size) { ByteStuffer::Instance->validator_recv_frame(link, data, size); } | ||
60 | |||
61 | void send_data(uint8_t link, const uint8_t* data, uint16_t size) { ByteStuffer::Instance->send_data(link, data, size); } | ||
62 | } | ||
63 | |||
64 | TEST_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 | |||
69 | TEST_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 | |||
74 | TEST_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 | |||
79 | TEST_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 | |||
85 | TEST_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 | } | ||
92 | TEST_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 | |||
102 | TEST_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 | |||
110 | TEST_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 | |||
121 | TEST_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 | |||
135 | TEST_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 | |||
147 | TEST_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 | |||
160 | TEST_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 | |||
174 | TEST_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 | |||
191 | TEST_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 | |||
208 | TEST_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 | |||
240 | TEST_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 | |||
251 | TEST_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 | |||
263 | TEST_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 | |||
276 | TEST_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 | |||
281 | TEST_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 | |||
288 | TEST_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 | |||
295 | TEST_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 | |||
302 | TEST_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 | |||
309 | TEST_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 | |||
316 | TEST_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 | |||
323 | TEST_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 | |||
330 | TEST_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 | |||
337 | TEST_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 | |||
353 | TEST_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 | |||
371 | TEST_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 | |||
390 | TEST_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 | |||
400 | TEST_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 | |||
410 | TEST_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 | |||
423 | TEST_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 | |||
438 | TEST_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 | } | ||