1 /******************************************************************************
2 *
3 * Copyright 2014 Google, Inc.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 *
17 ******************************************************************************/
18
19 #include <gtest/gtest.h>
20
21 #include "AllocationTestHarness.h"
22
23 #include <stdint.h>
24
25 #include "device/include/controller.h"
26 #include "hci_internals.h"
27 #include "osi/include/allocator.h"
28 #include "osi/include/osi.h"
29 #include "packet_fragmenter.h"
30 #include "test_stubs.h"
31
32 DECLARE_TEST_MODES(init, set_data_sizes, no_fragmentation, fragmentation,
33 ble_no_fragmentation, ble_fragmentation,
34 non_acl_passthrough_fragmentation, no_reassembly, reassembly,
35 non_acl_passthrough_reassembly, iso_no_reassembly,
36 iso_reassembly, iso_fragmentation, iso_no_fragmentation);
37
38 #define LOCAL_BLE_CONTROLLER_ID 1
39
40 static const char* sample_data =
41 "At this point they came in sight of thirty forty windmills that there are "
42 "on plain, and "
43 "as soon as Don Quixote saw them he said to his squire, \"Fortune is "
44 "arranging matters "
45 "for us better than we could have shaped our desires ourselves, for look "
46 "there, friend "
47 "Sancho Panza, where thirty or more monstrous giants present themselves, "
48 "all of whom I "
49 "mean to engage in battle and slay, and with whose spoils we shall begin "
50 "to make our "
51 "fortunes; for this is righteous warfare, and it is God's good service to "
52 "sweep so evil "
53 "a breed from off the face of the earth.\"";
54
55 static const char* small_sample_data = "\"What giants?\" said Sancho Panza.";
56 static const uint16_t test_handle_start = (0x1992 & 0xCFFF) | 0x2000;
57 static const uint16_t test_handle_continuation = (0x1992 & 0xCFFF) | 0x1000;
58 static const uint16_t test_iso_handle_complete_with_ts =
59 (0x0666 | (0x0002 << 12) | (0x0001 << 14));
60 static const uint16_t test_iso_handle_complete_without_ts =
61 (0x0666 | (0x0002 << 12));
62 static const uint16_t test_iso_handle_start_with_ts = (0x0666 | (0x0001 << 14));
63 static const uint16_t test_iso_handle_start_without_ts =
64 (0x0666); // Also base handle
65 static const uint16_t test_iso_handle_continuation = (0x0666 | (0x0001 << 12));
66 static const uint16_t test_iso_handle_end = (0x0666 | (0x0003 << 12));
67
68 static int packet_index;
69 static unsigned int data_size_sum;
70
71 static const packet_fragmenter_t* fragmenter;
72
73 static uint32_t iso_timestamp = 0x32122321;
74 static uint16_t iso_packet_seq = 0x1291;
75 static bool iso_has_ts = true;
76
manufacture_packet_for_fragmentation(uint16_t event,const char * data)77 static BT_HDR* manufacture_packet_for_fragmentation(uint16_t event,
78 const char* data) {
79 uint16_t data_length = strlen(data);
80 uint16_t size = data_length;
81 if (event == MSG_STACK_TO_HC_HCI_ACL) {
82 size += 4; // 2 for the handle, 2 for the length;
83 } else if (event == MSG_STACK_TO_HC_HCI_ISO) {
84 size += 8; // handle (2), length (2), packet_seq (2), sdu_len(2)
85 if (iso_has_ts) {
86 size += 4;
87 }
88 }
89
90 BT_HDR* packet = (BT_HDR*)osi_malloc(size + sizeof(BT_HDR));
91 packet->len = size;
92 packet->offset = 0;
93 packet->event = event;
94 packet->layer_specific = 0;
95 uint8_t* packet_data = packet->data;
96
97 if (event == MSG_STACK_TO_HC_HCI_ACL) {
98 UINT16_TO_STREAM(packet_data, test_handle_start);
99 UINT16_TO_STREAM(packet_data, data_length);
100 } else if (event == MSG_STACK_TO_HC_HCI_ISO) {
101 if (iso_has_ts) {
102 packet->layer_specific |= BT_ISO_HDR_CONTAINS_TS;
103 UINT16_TO_STREAM(packet_data, test_iso_handle_start_with_ts);
104 UINT16_TO_STREAM(packet_data, data_length + 8);
105 UINT32_TO_STREAM(packet_data, iso_timestamp);
106 } else {
107 UINT16_TO_STREAM(packet_data, test_iso_handle_start_without_ts);
108 UINT16_TO_STREAM(packet_data, data_length + 4);
109 }
110 UINT16_TO_STREAM(packet_data, iso_packet_seq);
111 UINT16_TO_STREAM(packet_data, data_length);
112 }
113
114 memcpy(packet_data, data, data_length);
115 return packet;
116 }
117
expect_packet_fragmented(uint16_t event,int max_acl_data_size,BT_HDR * packet,const char * expected_data,bool send_complete)118 static void expect_packet_fragmented(uint16_t event, int max_acl_data_size,
119 BT_HDR* packet, const char* expected_data,
120 bool send_complete) {
121 uint8_t* data = packet->data + packet->offset;
122 int expected_data_offset;
123 int length_to_check;
124
125 if (event == MSG_STACK_TO_HC_HCI_ACL) {
126 uint16_t handle;
127 uint16_t length;
128 STREAM_TO_UINT16(handle, data);
129 STREAM_TO_UINT16(length, data);
130
131 if (packet_index == 0)
132 EXPECT_EQ(test_handle_start, handle);
133 else
134 EXPECT_EQ(test_handle_continuation, handle);
135
136 int length_remaining = strlen(expected_data) - data_size_sum;
137 int packet_data_length = packet->len - HCI_ACL_PREAMBLE_SIZE;
138 EXPECT_EQ(packet_data_length, length);
139
140 if (length_remaining > max_acl_data_size)
141 EXPECT_EQ(max_acl_data_size, packet_data_length);
142
143 length_to_check = packet_data_length;
144 expected_data_offset = packet_index * max_acl_data_size;
145 packet_index++;
146 } else if (event == MSG_STACK_TO_HC_HCI_ISO) {
147 uint16_t handle;
148 uint16_t length;
149
150 STREAM_TO_UINT16(handle, data);
151 STREAM_TO_UINT16(length, data);
152
153 int length_remaining = strlen(expected_data) - data_size_sum;
154 int packet_data_length = packet->len - HCI_ISO_PREAMBLE_SIZE;
155
156 if (packet_index == 0) {
157 uint8_t hdr_size = 8; // ts, packet_seq, len
158
159 if (iso_has_ts) {
160 uint32_t timestamp;
161 STREAM_TO_UINT32(timestamp, data);
162 ASSERT_EQ(timestamp, iso_timestamp);
163
164 if (send_complete)
165 ASSERT_EQ(test_iso_handle_complete_with_ts, handle);
166 else
167 ASSERT_EQ(test_iso_handle_start_with_ts, handle);
168 } else {
169 if (send_complete)
170 ASSERT_EQ(test_iso_handle_complete_without_ts, handle);
171 else
172 ASSERT_EQ(test_iso_handle_start_without_ts, handle);
173 hdr_size -= 4;
174 }
175
176 uint16_t packet_seq;
177 STREAM_TO_UINT16(packet_seq, data);
178 ASSERT_EQ(packet_seq, iso_packet_seq);
179
180 uint16_t iso_sdu_length;
181 STREAM_TO_UINT16(iso_sdu_length, data);
182
183 ASSERT_EQ(iso_sdu_length, strlen(expected_data));
184
185 length_to_check = packet_data_length - hdr_size;
186 } else {
187 if (!send_complete)
188 ASSERT_EQ(test_iso_handle_continuation, handle);
189 else
190 ASSERT_EQ(test_iso_handle_end, handle);
191
192 length_to_check = packet_data_length;
193 }
194
195 if (length_remaining > max_acl_data_size)
196 ASSERT_EQ(max_acl_data_size, packet_data_length);
197
198 expected_data_offset = packet_index * max_acl_data_size;
199 if (expected_data_offset > 0) {
200 if (iso_has_ts) {
201 expected_data_offset -= 8;
202 } else {
203 expected_data_offset -= 4;
204 }
205 }
206 packet_index++;
207 } else {
208 length_to_check = strlen(expected_data);
209 expected_data_offset = 0;
210 }
211
212 for (int i = 0; i < length_to_check; i++) {
213 EXPECT_EQ(expected_data[expected_data_offset + i], data[i]);
214 data_size_sum++;
215 }
216
217 if (event == MSG_STACK_TO_HC_HCI_ISO || event == MSG_STACK_TO_HC_HCI_ACL)
218 EXPECT_TRUE(send_complete == (data_size_sum == strlen(expected_data)));
219
220 if (send_complete) osi_free(packet);
221 }
222
manufacture_acl_packet_and_then_reassemble(uint16_t event,uint16_t acl_size,const char * data)223 static void manufacture_acl_packet_and_then_reassemble(uint16_t event,
224 uint16_t acl_size,
225 const char* data) {
226 uint16_t data_length = strlen(data);
227 uint16_t total_length = data_length + 2; // 2 for l2cap length;
228 uint16_t length_sent = 0;
229 uint16_t l2cap_length = data_length - 2; // l2cap length field, 2 for the
230 // pretend channel id borrowed
231 // from the data
232
233 do {
234 int length_to_send = (length_sent + (acl_size - 4) < total_length)
235 ? (acl_size - 4)
236 : (total_length - length_sent);
237 BT_HDR* packet = (BT_HDR*)osi_malloc(length_to_send + 4 + sizeof(BT_HDR));
238 packet->len = length_to_send + 4;
239 packet->offset = 0;
240 packet->event = event;
241 packet->layer_specific = 0;
242
243 uint8_t* packet_data = packet->data;
244 if (length_sent == 0) { // first packet
245 UINT16_TO_STREAM(packet_data, test_handle_start);
246 UINT16_TO_STREAM(packet_data, length_to_send);
247 UINT16_TO_STREAM(packet_data, l2cap_length);
248 memcpy(packet_data, data, length_to_send - 2);
249 } else {
250 UINT16_TO_STREAM(packet_data, test_handle_continuation);
251 UINT16_TO_STREAM(packet_data, length_to_send);
252 memcpy(packet_data, data + length_sent - 2, length_to_send);
253 }
254
255 length_sent += length_to_send;
256 fragmenter->reassemble_and_dispatch(packet);
257 } while (length_sent < total_length);
258 }
259
manufacture_iso_packet_and_then_reassemble(uint16_t event,uint16_t iso_size,const char * data)260 static void manufacture_iso_packet_and_then_reassemble(uint16_t event,
261 uint16_t iso_size,
262 const char* data) {
263 uint16_t data_length = strlen(data);
264 uint16_t total_length;
265 uint16_t length_sent = 0;
266 uint16_t iso_length = data_length;
267 BT_HDR* packet;
268 uint8_t* packet_data;
269 uint8_t hdr_size = 4; // packet seq, sdu len
270
271 // ISO length (2), packet seq (2), optional timestamp (4)
272 total_length = data_length + 4;
273 if (iso_has_ts) total_length += 4;
274
275 do {
276 int length_to_send = (length_sent + (iso_size - 4) < total_length)
277 ? (iso_size - 4)
278 : (total_length - length_sent);
279
280 packet = (BT_HDR*)osi_malloc(length_to_send + 4 + sizeof(BT_HDR));
281 packet_data = packet->data;
282 packet->len = length_to_send + 4;
283 packet->offset = 0;
284 packet->event = event;
285 packet->layer_specific = 0;
286
287 bool is_complete = length_to_send == total_length;
288
289 if (length_sent == 0) { // first packet
290 if (iso_has_ts) {
291 hdr_size += 4;
292 if (is_complete) {
293 UINT16_TO_STREAM(packet_data, test_iso_handle_complete_with_ts);
294 } else {
295 UINT16_TO_STREAM(packet_data, test_iso_handle_start_with_ts);
296 }
297 } else {
298 if (is_complete) {
299 UINT16_TO_STREAM(packet_data, test_iso_handle_complete_without_ts);
300 } else {
301 UINT16_TO_STREAM(packet_data, test_iso_handle_start_without_ts);
302 }
303 }
304
305 UINT16_TO_STREAM(packet_data, length_to_send);
306
307 if (iso_has_ts) {
308 UINT32_TO_STREAM(packet_data, iso_timestamp);
309 }
310
311 UINT16_TO_STREAM(packet_data, iso_packet_seq);
312 UINT16_TO_STREAM(packet_data, iso_length);
313 memcpy(packet_data, data, length_to_send - hdr_size);
314 } else {
315 if (length_sent + length_to_send == total_length) {
316 UINT16_TO_STREAM(packet_data, test_iso_handle_end);
317 } else {
318 UINT16_TO_STREAM(packet_data, test_iso_handle_continuation);
319 }
320 UINT16_TO_STREAM(packet_data, length_to_send);
321 memcpy(packet_data, data + length_sent - hdr_size, length_to_send);
322 }
323
324 length_sent += length_to_send;
325 fragmenter->reassemble_and_dispatch(packet);
326 } while (length_sent < total_length);
327 }
328
manufacture_packet_and_then_reassemble(uint16_t event,uint16_t packet_size,const char * data)329 static void manufacture_packet_and_then_reassemble(uint16_t event,
330 uint16_t packet_size,
331 const char* data) {
332 uint16_t data_length = strlen(data);
333
334 if (event == MSG_HC_TO_STACK_HCI_ACL) {
335 manufacture_acl_packet_and_then_reassemble(event, packet_size, data);
336 } else if (event == MSG_HC_TO_STACK_HCI_ISO) {
337 manufacture_iso_packet_and_then_reassemble(event, packet_size, data);
338 } else {
339 BT_HDR* packet = (BT_HDR*)osi_malloc(data_length + sizeof(BT_HDR));
340 packet->len = data_length;
341 packet->offset = 0;
342 packet->event = event;
343 packet->layer_specific = 0;
344 memcpy(packet->data, data, data_length);
345
346 fragmenter->reassemble_and_dispatch(packet);
347 }
348 }
349
expect_packet_reassembled(uint16_t event,BT_HDR * packet,const char * expected_data)350 static void expect_packet_reassembled(uint16_t event, BT_HDR* packet,
351 const char* expected_data) {
352 uint16_t expected_data_length = strlen(expected_data);
353 uint8_t* data = packet->data + packet->offset;
354
355 if (event == MSG_HC_TO_STACK_HCI_ACL) {
356 uint16_t handle;
357 uint16_t length;
358 uint16_t l2cap_length;
359 STREAM_TO_UINT16(handle, data);
360 STREAM_TO_UINT16(length, data);
361 STREAM_TO_UINT16(l2cap_length, data);
362
363 EXPECT_EQ(test_handle_start, handle);
364 EXPECT_EQ(expected_data_length + 2, length);
365 EXPECT_EQ(expected_data_length - 2,
366 l2cap_length); // -2 for the pretend channel id
367 }
368
369 for (int i = 0; i < expected_data_length; i++) {
370 EXPECT_EQ(expected_data[i], data[i]);
371 data_size_sum++;
372 }
373
374 osi_free(packet);
375 }
376
expect_packet_reassembled_iso(uint16_t event,BT_HDR * packet,const char * expected_data,uint32_t expected_timestamp,uint16_t expected_packet_seq,bool is_complete=false)377 static void expect_packet_reassembled_iso(uint16_t event, BT_HDR* packet,
378 const char* expected_data,
379 uint32_t expected_timestamp,
380 uint16_t expected_packet_seq,
381 bool is_complete = false) {
382 uint16_t expected_data_length = strlen(expected_data);
383 uint8_t* data = packet->data;
384 uint8_t hdr_size = 8;
385 uint16_t handle;
386 uint16_t length;
387 uint16_t iso_length;
388 uint32_t timestamp;
389 uint16_t packet_seq;
390
391 ASSERT_EQ(event, MSG_HC_TO_STACK_HCI_ISO);
392
393 STREAM_TO_UINT16(handle, data);
394 STREAM_TO_UINT16(length, data);
395 if (iso_has_ts) {
396 STREAM_TO_UINT32(timestamp, data);
397 ASSERT_TRUE((packet->layer_specific & BT_ISO_HDR_CONTAINS_TS) != 0);
398 ASSERT_EQ(timestamp, expected_timestamp);
399 ASSERT_EQ(is_complete ? test_iso_handle_complete_with_ts
400 : test_iso_handle_start_with_ts,
401 handle);
402 } else {
403 ASSERT_TRUE((packet->layer_specific & BT_ISO_HDR_CONTAINS_TS) == 0);
404 ASSERT_EQ(is_complete ? test_iso_handle_complete_without_ts
405 : test_iso_handle_start_without_ts,
406 handle);
407 hdr_size -= 4;
408 }
409
410 ASSERT_EQ(expected_data_length + hdr_size, length);
411
412 STREAM_TO_UINT16(packet_seq, data);
413 ASSERT_EQ(packet_seq, expected_packet_seq);
414
415 STREAM_TO_UINT16(iso_length, data);
416 ASSERT_EQ(expected_data_length, iso_length);
417
418 for (int i = 0; i < expected_data_length; i++) {
419 ASSERT_EQ(expected_data[i], data[i]);
420 data_size_sum++;
421 }
422
423 osi_free(packet);
424 }
425
426 STUB_FUNCTION(void, fragmented_callback, (BT_HDR * packet, bool send_complete))
427 DURING(no_fragmentation) AT_CALL(0) {
428 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
429 small_sample_data, send_complete);
430 return;
431 }
432
DURING(fragmentation)433 DURING(fragmentation) {
434 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
435 send_complete);
436 return;
437 }
438
439 DURING(ble_no_fragmentation) AT_CALL(0) {
440 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
441 small_sample_data, send_complete);
442 return;
443 }
444
DURING(ble_fragmentation)445 DURING(ble_fragmentation) {
446 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
447 send_complete);
448 return;
449 }
450
DURING(iso_fragmentation)451 DURING(iso_fragmentation) {
452 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ISO, 10, packet, sample_data,
453 send_complete);
454 return;
455 }
456
DURING(iso_no_fragmentation)457 DURING(iso_no_fragmentation) {
458 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ISO, 42, packet,
459 small_sample_data, send_complete);
460 return;
461 }
462
463 DURING(non_acl_passthrough_fragmentation) AT_CALL(0) {
464 expect_packet_fragmented(MSG_STACK_TO_HC_HCI_CMD, 10, packet, sample_data,
465 send_complete);
466 return;
467 }
468
469 UNEXPECTED_CALL;
470 }
471
472 STUB_FUNCTION(void, reassembled_callback, (BT_HDR * packet))
473 DURING(no_reassembly) AT_CALL(0) {
474 expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, small_sample_data);
475 return;
476 }
477
478 DURING(reassembly) AT_CALL(0) {
479 expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, sample_data);
480 return;
481 }
482
483 DURING(iso_reassembly) AT_CALL(0) {
484 expect_packet_reassembled_iso(MSG_HC_TO_STACK_HCI_ISO, packet, sample_data,
485 iso_timestamp, iso_packet_seq);
486 return;
487 }
488
489 DURING(iso_no_reassembly) AT_CALL(0) {
490 expect_packet_reassembled_iso(MSG_HC_TO_STACK_HCI_ISO, packet,
491 small_sample_data, iso_timestamp,
492 iso_packet_seq, true);
493 return;
494 }
495
496 DURING(non_acl_passthrough_reassembly) AT_CALL(0) {
497 expect_packet_reassembled(MSG_HC_TO_STACK_HCI_EVT, packet, sample_data);
498 return;
499 }
500
501 UNEXPECTED_CALL;
502 }
503
504 STUB_FUNCTION(void, transmit_finished_callback,
505 (UNUSED_ATTR BT_HDR * packet,
506 UNUSED_ATTR bool sent_all_fragments))
507 UNEXPECTED_CALL;
508 }
509
510 STUB_FUNCTION(uint16_t, get_acl_data_size_classic, (void))
511 DURING(no_fragmentation, non_acl_passthrough_fragmentation, no_reassembly)
512 return 42;
513 DURING(fragmentation) return 10;
514 DURING(no_reassembly) return 1337;
515
516 UNEXPECTED_CALL;
517 return 0;
518 }
519
520 STUB_FUNCTION(uint16_t, get_acl_data_size_ble, (void))
521 DURING(ble_no_fragmentation) return 42;
522 DURING(ble_fragmentation) return 10;
523
524 UNEXPECTED_CALL;
525 return 0;
526 }
527
528 STUB_FUNCTION(uint16_t, get_iso_data_size, (void))
529 DURING(iso_no_fragmentation) return 42;
530 DURING(iso_fragmentation) return 10;
531
532 UNEXPECTED_CALL;
533 return 0;
534 }
535
536 static void reset_for(TEST_MODES_T next) {
537 RESET_CALL_COUNT(fragmented_callback);
538 RESET_CALL_COUNT(reassembled_callback);
539 RESET_CALL_COUNT(transmit_finished_callback);
540 RESET_CALL_COUNT(get_acl_data_size_classic);
541 RESET_CALL_COUNT(get_acl_data_size_ble);
542 RESET_CALL_COUNT(get_iso_data_size);
543 CURRENT_TEST_MODE = next;
544 }
545
546 class PacketFragmenterTest : public AllocationTestHarness {
547 protected:
548 void SetUp() override {
549 AllocationTestHarness::SetUp();
550 fragmenter =
551 packet_fragmenter_get_test_interface(&controller, &allocator_malloc);
552
553 packet_index = 0;
554 data_size_sum = 0;
555
556 callbacks.fragmented = fragmented_callback;
557 callbacks.reassembled = reassembled_callback;
558 callbacks.transmit_finished = transmit_finished_callback;
559 controller.get_acl_data_size_classic = get_acl_data_size_classic;
560 controller.get_acl_data_size_ble = get_acl_data_size_ble;
561 controller.get_iso_data_size = get_iso_data_size;
562
563 reset_for(init);
564 fragmenter->init(&callbacks);
565 }
566
567 void TearDown() override {
568 fragmenter->cleanup();
569 AllocationTestHarness::TearDown();
570 }
571
572 controller_t controller;
573 packet_fragmenter_callbacks_t callbacks;
574 };
575
576 TEST_F(PacketFragmenterTest, test_no_fragment_necessary) {
577 reset_for(no_fragmentation);
578 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
579 small_sample_data);
580 fragmenter->fragment_and_dispatch(packet);
581
582 EXPECT_EQ(strlen(small_sample_data), data_size_sum);
583 EXPECT_CALL_COUNT(fragmented_callback, 1);
584 }
585
586 TEST_F(PacketFragmenterTest, test_fragment_necessary) {
587 reset_for(fragmentation);
588 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
589 sample_data);
590 fragmenter->fragment_and_dispatch(packet);
591
592 EXPECT_EQ(strlen(sample_data), data_size_sum);
593 }
594
595 TEST_F(PacketFragmenterTest, test_ble_no_fragment_necessary) {
596 reset_for(ble_no_fragmentation);
597 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
598 small_sample_data);
599 packet->event |= LOCAL_BLE_CONTROLLER_ID;
600 fragmenter->fragment_and_dispatch(packet);
601
602 EXPECT_EQ(strlen(small_sample_data), data_size_sum);
603 EXPECT_CALL_COUNT(fragmented_callback, 1);
604 }
605
606 TEST_F(PacketFragmenterTest, test_ble_fragment_necessary) {
607 reset_for(ble_fragmentation);
608 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
609 sample_data);
610 packet->event |= LOCAL_BLE_CONTROLLER_ID;
611 fragmenter->fragment_and_dispatch(packet);
612
613 EXPECT_EQ(strlen(sample_data), data_size_sum);
614 }
615
616 TEST_F(PacketFragmenterTest, test_non_acl_passthrough_fragmentation) {
617 reset_for(non_acl_passthrough_fragmentation);
618 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_CMD,
619 sample_data);
620 fragmenter->fragment_and_dispatch(packet);
621
622 EXPECT_EQ(strlen(sample_data), data_size_sum);
623 EXPECT_CALL_COUNT(fragmented_callback, 1);
624 }
625
626 TEST_F(PacketFragmenterTest, test_no_reassembly_necessary) {
627 reset_for(no_reassembly);
628 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 1337,
629 small_sample_data);
630
631 EXPECT_EQ(strlen(small_sample_data), data_size_sum);
632 EXPECT_CALL_COUNT(reassembled_callback, 1);
633 }
634
635 TEST_F(PacketFragmenterTest, test_reassembly_necessary) {
636 reset_for(reassembly);
637 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 42,
638 sample_data);
639
640 EXPECT_EQ(strlen(sample_data), data_size_sum);
641 EXPECT_CALL_COUNT(reassembled_callback, 1);
642 }
643
644 TEST_F(PacketFragmenterTest, test_non_acl_passthrough_reasseembly) {
645 reset_for(non_acl_passthrough_reassembly);
646 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_EVT, 42,
647 sample_data);
648
649 EXPECT_EQ(strlen(sample_data), data_size_sum);
650 EXPECT_CALL_COUNT(reassembled_callback, 1);
651 }
652
653 TEST_F(PacketFragmenterTest, test_iso_fragment_necessary) {
654 reset_for(iso_fragmentation);
655 iso_has_ts = true;
656
657 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ISO,
658 sample_data);
659 packet->event |= LOCAL_BLE_CONTROLLER_ID;
660 fragmenter->fragment_and_dispatch(packet);
661
662 ASSERT_EQ(strlen(sample_data), data_size_sum);
663 }
664
665 TEST_F(PacketFragmenterTest, test_iso_no_fragment_necessary) {
666 reset_for(iso_no_fragmentation);
667 iso_has_ts = true;
668
669 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ISO,
670 small_sample_data);
671 packet->event |= LOCAL_BLE_CONTROLLER_ID;
672 fragmenter->fragment_and_dispatch(packet);
673
674 ASSERT_EQ(strlen(small_sample_data), data_size_sum);
675 }
676
677 TEST_F(PacketFragmenterTest, test_iso_fragment_necessary_no_ts) {
678 reset_for(iso_fragmentation);
679 iso_has_ts = false;
680 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ISO,
681 sample_data);
682 packet->event |= LOCAL_BLE_CONTROLLER_ID;
683 fragmenter->fragment_and_dispatch(packet);
684
685 ASSERT_EQ(strlen(sample_data), data_size_sum);
686 }
687
688 TEST_F(PacketFragmenterTest, test_iso_no_fragment_necessary_no_ts) {
689 reset_for(iso_no_fragmentation);
690 iso_has_ts = false;
691 BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ISO,
692 small_sample_data);
693 packet->event |= LOCAL_BLE_CONTROLLER_ID;
694 fragmenter->fragment_and_dispatch(packet);
695
696 ASSERT_EQ(strlen(small_sample_data), data_size_sum);
697 }
698
699 TEST_F(PacketFragmenterTest, test_iso_no_reassembly_necessary) {
700 reset_for(iso_no_reassembly);
701 iso_has_ts = true;
702 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ISO, 50,
703 small_sample_data);
704
705 ASSERT_EQ(strlen(small_sample_data), data_size_sum);
706 EXPECT_CALL_COUNT(reassembled_callback, 1);
707 }
708
709 TEST_F(PacketFragmenterTest, test_iso_reassembly_necessary) {
710 reset_for(iso_reassembly);
711 iso_has_ts = true;
712 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ISO, 42,
713 sample_data);
714
715 ASSERT_EQ(strlen(sample_data), data_size_sum);
716 EXPECT_CALL_COUNT(reassembled_callback, 1);
717 }
718
719 TEST_F(PacketFragmenterTest, test_iso_no_reassembly_necessary_no_ts) {
720 reset_for(iso_no_reassembly);
721 iso_has_ts = false;
722 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ISO, (42 + 4),
723 small_sample_data);
724
725 ASSERT_EQ(strlen(small_sample_data), data_size_sum);
726 EXPECT_CALL_COUNT(reassembled_callback, 1);
727 }
728
729 TEST_F(PacketFragmenterTest, test_iso_reassembly_necessary_no_ts) {
730 reset_for(iso_reassembly);
731 iso_has_ts = false;
732 manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ISO, 42,
733 sample_data);
734
735 ASSERT_EQ(strlen(sample_data), data_size_sum);
736 EXPECT_CALL_COUNT(reassembled_callback, 1);
737 }
738