hci/test/packet_fragmenter_test.cc - platform/system/bt - Git at Google

 /******************************************************************************
  *
  *  Copyright 2014 Google, Inc.
  *
  *  Licensed under the Apache License, Version 2.0 (the "License");
  *  you may not use this file except in compliance with the License.
  *  You may obtain a copy of the License at:
  *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  *  Unless required by applicable law or agreed to in writing, software
  *  distributed under the License is distributed on an "AS IS" BASIS,
  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  *  See the License for the specific language governing permissions and
  *  limitations under the License.
  *
  ******************************************************************************/

 #include <gtest/gtest.h>

 #include "AllocationTestHarness.h"

 #include <stdint.h>

 #include "device/include/controller.h"
 #include "hci_internals.h"
 #include "osi/include/allocator.h"
 #include "osi/include/osi.h"
 #include "packet_fragmenter.h"
 #include "test_stubs.h"

 DECLARE_TEST_MODES(init, set_data_sizes, no_fragmentation, fragmentation,
                    ble_no_fragmentation, ble_fragmentation,
                    non_acl_passthrough_fragmentation, no_reassembly, reassembly,
                    non_acl_passthrough_reassembly);

 #define LOCAL_BLE_CONTROLLER_ID 1

 static const char* sample_data =
     "At this point they came in sight of thirty forty windmills that there are "
     "on plain, and "
     "as soon as Don Quixote saw them he said to his squire, \"Fortune is "
     "arranging matters "
     "for us better than we could have shaped our desires ourselves, for look "
     "there, friend "
     "Sancho Panza, where thirty or more monstrous giants present themselves, "
     "all of whom I "
     "mean to engage in battle and slay, and with whose spoils we shall begin "
     "to make our "
     "fortunes; for this is righteous warfare, and it is God's good service to "
     "sweep so evil "
     "a breed from off the face of the earth.\"";

 static const char* small_sample_data = "\"What giants?\" said Sancho Panza.";
 static const uint16_t test_handle_start = (0x1992 & 0xCFFF) | 0x2000;
 static const uint16_t test_handle_continuation = (0x1992 & 0xCFFF) | 0x1000;
 static int packet_index;
 static unsigned int data_size_sum;

 static const packet_fragmenter_t* fragmenter;

 static BT_HDR* manufacture_packet_for_fragmentation(uint16_t event,
                                                     const char* data) {
   uint16_t data_length = strlen(data);
   uint16_t size = data_length;
   if (event == MSG_STACK_TO_HC_HCI_ACL) {
     size += 4;  // 2 for the handle, 2 for the length;
   }

   BT_HDR* packet = (BT_HDR*)osi_malloc(size + sizeof(BT_HDR));
   packet->len = size;
   packet->offset = 0;
   packet->event = event;
   packet->layer_specific = 0;
   uint8_t* packet_data = packet->data;

   if (event == MSG_STACK_TO_HC_HCI_ACL) {
     UINT16_TO_STREAM(packet_data, test_handle_start);
     UINT16_TO_STREAM(packet_data, data_length);
   }

   memcpy(packet_data, data, data_length);
   return packet;
 }

 static void expect_packet_fragmented(uint16_t event, int max_acl_data_size,
                                      BT_HDR* packet, const char* expected_data,
                                      bool send_complete) {
   uint8_t* data = packet->data + packet->offset;
   int expected_data_offset;
   int length_to_check;

   if (event == MSG_STACK_TO_HC_HCI_ACL) {
     uint16_t handle;
     uint16_t length;
     STREAM_TO_UINT16(handle, data);
     STREAM_TO_UINT16(length, data);

     if (packet_index == 0)
       EXPECT_EQ(test_handle_start, handle);
     else
       EXPECT_EQ(test_handle_continuation, handle);

     int length_remaining = strlen(expected_data) - data_size_sum;
     int packet_data_length = packet->len - HCI_ACL_PREAMBLE_SIZE;
     EXPECT_EQ(packet_data_length, length);

     if (length_remaining > max_acl_data_size)
       EXPECT_EQ(max_acl_data_size, packet_data_length);

     length_to_check = packet_data_length;
     expected_data_offset = packet_index * max_acl_data_size;
     packet_index++;
   } else {
     length_to_check = strlen(expected_data);
     expected_data_offset = 0;
   }

   for (int i = 0; i < length_to_check; i++) {
     EXPECT_EQ(expected_data[expected_data_offset + i], data[i]);
     data_size_sum++;
   }

   if (event == MSG_STACK_TO_HC_HCI_ACL)
     EXPECT_TRUE(send_complete == (data_size_sum == strlen(expected_data)));

   if (send_complete) osi_free(packet);
 }

 static void manufacture_packet_and_then_reassemble(uint16_t event,
                                                    uint16_t acl_size,
                                                    const char* data) {
   uint16_t data_length = strlen(data);

   if (event == MSG_HC_TO_STACK_HCI_ACL) {
     uint16_t total_length = data_length + 2;  // 2 for l2cap length;
     uint16_t length_sent = 0;
     uint16_t l2cap_length = data_length - 2;  // l2cap length field, 2 for the
                                               // pretend channel id borrowed
                                               // from the data

     do {
       int length_to_send = (length_sent + (acl_size - 4) < total_length)
                                ? (acl_size - 4)
                                : (total_length - length_sent);
       BT_HDR* packet = (BT_HDR*)osi_malloc(length_to_send + 4 + sizeof(BT_HDR));
       packet->len = length_to_send + 4;
       packet->offset = 0;
       packet->event = event;
       packet->layer_specific = 0;

       uint8_t* packet_data = packet->data;
       if (length_sent == 0) {  // first packet
         UINT16_TO_STREAM(packet_data, test_handle_start);
         UINT16_TO_STREAM(packet_data, length_to_send);
         UINT16_TO_STREAM(packet_data, l2cap_length);
         memcpy(packet_data, data, length_to_send - 2);
       } else {
         UINT16_TO_STREAM(packet_data, test_handle_continuation);
         UINT16_TO_STREAM(packet_data, length_to_send);
         memcpy(packet_data, data + length_sent - 2, length_to_send);
       }

       length_sent += length_to_send;
       fragmenter->reassemble_and_dispatch(packet);
     } while (length_sent < total_length);
   } else {
     BT_HDR* packet = (BT_HDR*)osi_malloc(data_length + sizeof(BT_HDR));
     packet->len = data_length;
     packet->offset = 0;
     packet->event = event;
     packet->layer_specific = 0;
     memcpy(packet->data, data, data_length);

     fragmenter->reassemble_and_dispatch(packet);
   }
 }

 static void expect_packet_reassembled(uint16_t event, BT_HDR* packet,
                                       const char* expected_data) {
   uint16_t expected_data_length = strlen(expected_data);
   uint8_t* data = packet->data + packet->offset;

   if (event == MSG_HC_TO_STACK_HCI_ACL) {
     uint16_t handle;
     uint16_t length;
     uint16_t l2cap_length;
     STREAM_TO_UINT16(handle, data);
     STREAM_TO_UINT16(length, data);
     STREAM_TO_UINT16(l2cap_length, data);

     EXPECT_EQ(test_handle_start, handle);
     EXPECT_EQ(expected_data_length + 2, length);
     EXPECT_EQ(expected_data_length - 2,
               l2cap_length);  // -2 for the pretend channel id
   }

   for (int i = 0; i < expected_data_length; i++) {
     EXPECT_EQ(expected_data[i], data[i]);
     data_size_sum++;
   }

   osi_free(packet);
 }

 STUB_FUNCTION(void, fragmented_callback, (BT_HDR * packet, bool send_complete))
 DURING(no_fragmentation) AT_CALL(0) {
   expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
                            small_sample_data, send_complete);
   return;
 }

 DURING(fragmentation) {
   expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
                            send_complete);
   return;
 }

 DURING(ble_no_fragmentation) AT_CALL(0) {
   expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
                            small_sample_data, send_complete);
   return;
 }

 DURING(ble_fragmentation) {
   expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
                            send_complete);
   return;
 }

 DURING(non_acl_passthrough_fragmentation) AT_CALL(0) {
   expect_packet_fragmented(MSG_STACK_TO_HC_HCI_CMD, 10, packet, sample_data,
                            send_complete);
   return;
 }

 UNEXPECTED_CALL;
 }

 STUB_FUNCTION(void, reassembled_callback, (BT_HDR * packet))
 DURING(no_reassembly) AT_CALL(0) {
   expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, small_sample_data);
   return;
 }

 DURING(reassembly) AT_CALL(0) {
   expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, sample_data);
   return;
 }

 DURING(non_acl_passthrough_reassembly) AT_CALL(0) {
   expect_packet_reassembled(MSG_HC_TO_STACK_HCI_EVT, packet, sample_data);
   return;
 }

 UNEXPECTED_CALL;
 }

 STUB_FUNCTION(void, transmit_finished_callback,
               (UNUSED_ATTR BT_HDR * packet,
                UNUSED_ATTR bool sent_all_fragments))
 UNEXPECTED_CALL;
 }

 STUB_FUNCTION(uint16_t, get_acl_data_size_classic, (void))
 DURING(no_fragmentation, non_acl_passthrough_fragmentation, no_reassembly)
 return 42;
 DURING(fragmentation) return 10;
 DURING(no_reassembly) return 1337;

 UNEXPECTED_CALL;
 return 0;
 }

 STUB_FUNCTION(uint16_t, get_acl_data_size_ble, (void))
 DURING(ble_no_fragmentation) return 42;
 DURING(ble_fragmentation) return 10;

 UNEXPECTED_CALL;
 return 0;
 }

 static void reset_for(TEST_MODES_T next) {
   RESET_CALL_COUNT(fragmented_callback);
   RESET_CALL_COUNT(reassembled_callback);
   RESET_CALL_COUNT(transmit_finished_callback);
   RESET_CALL_COUNT(get_acl_data_size_classic);
   RESET_CALL_COUNT(get_acl_data_size_ble);
   CURRENT_TEST_MODE = next;
 }

 class PacketFragmenterTest : public AllocationTestHarness {
  protected:
   virtual void SetUp() {
     AllocationTestHarness::SetUp();
     fragmenter =
         packet_fragmenter_get_test_interface(&controller, &allocator_malloc);

     packet_index = 0;
     data_size_sum = 0;

     callbacks.fragmented = fragmented_callback;
     callbacks.reassembled = reassembled_callback;
     callbacks.transmit_finished = transmit_finished_callback;
     controller.get_acl_data_size_classic = get_acl_data_size_classic;
     controller.get_acl_data_size_ble = get_acl_data_size_ble;

     reset_for(init);
     fragmenter->init(&callbacks);
   }

   virtual void TearDown() {
     fragmenter->cleanup();
     AllocationTestHarness::TearDown();
   }

   controller_t controller;
   packet_fragmenter_callbacks_t callbacks;
 };

 TEST_F(PacketFragmenterTest, test_no_fragment_necessary) {
   reset_for(no_fragmentation);
   BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
                                                         small_sample_data);
   fragmenter->fragment_and_dispatch(packet);

   EXPECT_EQ(strlen(small_sample_data), data_size_sum);
   EXPECT_CALL_COUNT(fragmented_callback, 1);
 }

 TEST_F(PacketFragmenterTest, test_fragment_necessary) {
   reset_for(fragmentation);
   BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
                                                         sample_data);
   fragmenter->fragment_and_dispatch(packet);

   EXPECT_EQ(strlen(sample_data), data_size_sum);
 }

 TEST_F(PacketFragmenterTest, test_ble_no_fragment_necessary) {
   reset_for(ble_no_fragmentation);
   BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
                                                         small_sample_data);
   packet->event |= LOCAL_BLE_CONTROLLER_ID;
   fragmenter->fragment_and_dispatch(packet);

   EXPECT_EQ(strlen(small_sample_data), data_size_sum);
   EXPECT_CALL_COUNT(fragmented_callback, 1);
 }

 TEST_F(PacketFragmenterTest, test_ble_fragment_necessary) {
   reset_for(ble_fragmentation);
   BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
                                                         sample_data);
   packet->event |= LOCAL_BLE_CONTROLLER_ID;
   fragmenter->fragment_and_dispatch(packet);

   EXPECT_EQ(strlen(sample_data), data_size_sum);
 }

 TEST_F(PacketFragmenterTest, test_non_acl_passthrough_fragmentation) {
   reset_for(non_acl_passthrough_fragmentation);
   BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_CMD,
                                                         sample_data);
   fragmenter->fragment_and_dispatch(packet);

   EXPECT_EQ(strlen(sample_data), data_size_sum);
   EXPECT_CALL_COUNT(fragmented_callback, 1);
 }

 TEST_F(PacketFragmenterTest, test_no_reassembly_necessary) {
   reset_for(no_reassembly);
   manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 1337,
                                          small_sample_data);

   EXPECT_EQ(strlen(small_sample_data), data_size_sum);
   EXPECT_CALL_COUNT(reassembled_callback, 1);
 }

 TEST_F(PacketFragmenterTest, test_reassembly_necessary) {
   reset_for(reassembly);
   manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 42,
                                          sample_data);

   EXPECT_EQ(strlen(sample_data), data_size_sum);
   EXPECT_CALL_COUNT(reassembled_callback, 1);
 }

 TEST_F(PacketFragmenterTest, test_non_acl_passthrough_reasseembly) {
   reset_for(non_acl_passthrough_reassembly);
   manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_EVT, 42,
                                          sample_data);

   EXPECT_EQ(strlen(sample_data), data_size_sum);
   EXPECT_CALL_COUNT(reassembled_callback, 1);
 }
	/******************************************************************************
	*
	* Copyright 2014 Google, Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at:
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	******************************************************************************/

	#include <gtest/gtest.h>

	#include "AllocationTestHarness.h"

	#include <stdint.h>

	#include "device/include/controller.h"
	#include "hci_internals.h"
	#include "osi/include/allocator.h"
	#include "osi/include/osi.h"
	#include "packet_fragmenter.h"
	#include "test_stubs.h"

	DECLARE_TEST_MODES(init, set_data_sizes, no_fragmentation, fragmentation,
	ble_no_fragmentation, ble_fragmentation,
	non_acl_passthrough_fragmentation, no_reassembly, reassembly,
	non_acl_passthrough_reassembly);

	#define LOCAL_BLE_CONTROLLER_ID 1

	static const char* sample_data =
	"At this point they came in sight of thirty forty windmills that there are "
	"on plain, and "
	"as soon as Don Quixote saw them he said to his squire, \"Fortune is "
	"arranging matters "
	"for us better than we could have shaped our desires ourselves, for look "
	"there, friend "
	"Sancho Panza, where thirty or more monstrous giants present themselves, "
	"all of whom I "
	"mean to engage in battle and slay, and with whose spoils we shall begin "
	"to make our "
	"fortunes; for this is righteous warfare, and it is God's good service to "
	"sweep so evil "
	"a breed from off the face of the earth.\"";

	static const char* small_sample_data = "\"What giants?\" said Sancho Panza.";
	static const uint16_t test_handle_start = (0x1992 & 0xCFFF) \| 0x2000;
	static const uint16_t test_handle_continuation = (0x1992 & 0xCFFF) \| 0x1000;
	static int packet_index;
	static unsigned int data_size_sum;

	static const packet_fragmenter_t* fragmenter;

	static BT_HDR* manufacture_packet_for_fragmentation(uint16_t event,
	const char* data) {
	uint16_t data_length = strlen(data);
	uint16_t size = data_length;
	if (event == MSG_STACK_TO_HC_HCI_ACL) {
	size += 4; // 2 for the handle, 2 for the length;
	}

	BT_HDR* packet = (BT_HDR*)osi_malloc(size + sizeof(BT_HDR));
	packet->len = size;
	packet->offset = 0;
	packet->event = event;
	packet->layer_specific = 0;
	uint8_t* packet_data = packet->data;

	if (event == MSG_STACK_TO_HC_HCI_ACL) {
	UINT16_TO_STREAM(packet_data, test_handle_start);
	UINT16_TO_STREAM(packet_data, data_length);
	}

	memcpy(packet_data, data, data_length);
	return packet;
	}

	static void expect_packet_fragmented(uint16_t event, int max_acl_data_size,
	BT_HDR* packet, const char* expected_data,
	bool send_complete) {
	uint8_t* data = packet->data + packet->offset;
	int expected_data_offset;
	int length_to_check;

	if (event == MSG_STACK_TO_HC_HCI_ACL) {
	uint16_t handle;
	uint16_t length;
	STREAM_TO_UINT16(handle, data);
	STREAM_TO_UINT16(length, data);

	if (packet_index == 0)
	EXPECT_EQ(test_handle_start, handle);
	else
	EXPECT_EQ(test_handle_continuation, handle);

	int length_remaining = strlen(expected_data) - data_size_sum;
	int packet_data_length = packet->len - HCI_ACL_PREAMBLE_SIZE;
	EXPECT_EQ(packet_data_length, length);

	if (length_remaining > max_acl_data_size)
	EXPECT_EQ(max_acl_data_size, packet_data_length);

	length_to_check = packet_data_length;
	expected_data_offset = packet_index * max_acl_data_size;
	packet_index++;
	} else {
	length_to_check = strlen(expected_data);
	expected_data_offset = 0;
	}

	for (int i = 0; i < length_to_check; i++) {
	EXPECT_EQ(expected_data[expected_data_offset + i], data[i]);
	data_size_sum++;
	}

	if (event == MSG_STACK_TO_HC_HCI_ACL)
	EXPECT_TRUE(send_complete == (data_size_sum == strlen(expected_data)));

	if (send_complete) osi_free(packet);
	}

	static void manufacture_packet_and_then_reassemble(uint16_t event,
	uint16_t acl_size,
	const char* data) {
	uint16_t data_length = strlen(data);

	if (event == MSG_HC_TO_STACK_HCI_ACL) {
	uint16_t total_length = data_length + 2; // 2 for l2cap length;
	uint16_t length_sent = 0;
	uint16_t l2cap_length = data_length - 2; // l2cap length field, 2 for the
	// pretend channel id borrowed
	// from the data

	do {
	int length_to_send = (length_sent + (acl_size - 4) < total_length)
	? (acl_size - 4)
	: (total_length - length_sent);
	BT_HDR* packet = (BT_HDR*)osi_malloc(length_to_send + 4 + sizeof(BT_HDR));
	packet->len = length_to_send + 4;
	packet->offset = 0;
	packet->event = event;
	packet->layer_specific = 0;

	uint8_t* packet_data = packet->data;
	if (length_sent == 0) { // first packet
	UINT16_TO_STREAM(packet_data, test_handle_start);
	UINT16_TO_STREAM(packet_data, length_to_send);
	UINT16_TO_STREAM(packet_data, l2cap_length);
	memcpy(packet_data, data, length_to_send - 2);
	} else {
	UINT16_TO_STREAM(packet_data, test_handle_continuation);
	UINT16_TO_STREAM(packet_data, length_to_send);
	memcpy(packet_data, data + length_sent - 2, length_to_send);
	}

	length_sent += length_to_send;
	fragmenter->reassemble_and_dispatch(packet);
	} while (length_sent < total_length);
	} else {
	BT_HDR* packet = (BT_HDR*)osi_malloc(data_length + sizeof(BT_HDR));
	packet->len = data_length;
	packet->offset = 0;
	packet->event = event;
	packet->layer_specific = 0;
	memcpy(packet->data, data, data_length);

	fragmenter->reassemble_and_dispatch(packet);
	}
	}

	static void expect_packet_reassembled(uint16_t event, BT_HDR* packet,
	const char* expected_data) {
	uint16_t expected_data_length = strlen(expected_data);
	uint8_t* data = packet->data + packet->offset;

	if (event == MSG_HC_TO_STACK_HCI_ACL) {
	uint16_t handle;
	uint16_t length;
	uint16_t l2cap_length;
	STREAM_TO_UINT16(handle, data);
	STREAM_TO_UINT16(length, data);
	STREAM_TO_UINT16(l2cap_length, data);

	EXPECT_EQ(test_handle_start, handle);
	EXPECT_EQ(expected_data_length + 2, length);
	EXPECT_EQ(expected_data_length - 2,
	l2cap_length); // -2 for the pretend channel id
	}

	for (int i = 0; i < expected_data_length; i++) {
	EXPECT_EQ(expected_data[i], data[i]);
	data_size_sum++;
	}

	osi_free(packet);
	}

	STUB_FUNCTION(void, fragmented_callback, (BT_HDR * packet, bool send_complete))
	DURING(no_fragmentation) AT_CALL(0) {
	expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
	small_sample_data, send_complete);
	return;
	}

	DURING(fragmentation) {
	expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
	send_complete);
	return;
	}

	DURING(ble_no_fragmentation) AT_CALL(0) {
	expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 42, packet,
	small_sample_data, send_complete);
	return;
	}

	DURING(ble_fragmentation) {
	expect_packet_fragmented(MSG_STACK_TO_HC_HCI_ACL, 10, packet, sample_data,
	send_complete);
	return;
	}

	DURING(non_acl_passthrough_fragmentation) AT_CALL(0) {
	expect_packet_fragmented(MSG_STACK_TO_HC_HCI_CMD, 10, packet, sample_data,
	send_complete);
	return;
	}

	UNEXPECTED_CALL;
	}

	STUB_FUNCTION(void, reassembled_callback, (BT_HDR * packet))
	DURING(no_reassembly) AT_CALL(0) {
	expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, small_sample_data);
	return;
	}

	DURING(reassembly) AT_CALL(0) {
	expect_packet_reassembled(MSG_HC_TO_STACK_HCI_ACL, packet, sample_data);
	return;
	}

	DURING(non_acl_passthrough_reassembly) AT_CALL(0) {
	expect_packet_reassembled(MSG_HC_TO_STACK_HCI_EVT, packet, sample_data);
	return;
	}

	UNEXPECTED_CALL;
	}

	STUB_FUNCTION(void, transmit_finished_callback,
	(UNUSED_ATTR BT_HDR * packet,
	UNUSED_ATTR bool sent_all_fragments))
	UNEXPECTED_CALL;
	}

	STUB_FUNCTION(uint16_t, get_acl_data_size_classic, (void))
	DURING(no_fragmentation, non_acl_passthrough_fragmentation, no_reassembly)
	return 42;
	DURING(fragmentation) return 10;
	DURING(no_reassembly) return 1337;

	UNEXPECTED_CALL;
	return 0;
	}

	STUB_FUNCTION(uint16_t, get_acl_data_size_ble, (void))
	DURING(ble_no_fragmentation) return 42;
	DURING(ble_fragmentation) return 10;

	UNEXPECTED_CALL;
	return 0;
	}

	static void reset_for(TEST_MODES_T next) {
	RESET_CALL_COUNT(fragmented_callback);
	RESET_CALL_COUNT(reassembled_callback);
	RESET_CALL_COUNT(transmit_finished_callback);
	RESET_CALL_COUNT(get_acl_data_size_classic);
	RESET_CALL_COUNT(get_acl_data_size_ble);
	CURRENT_TEST_MODE = next;
	}

	class PacketFragmenterTest : public AllocationTestHarness {
	protected:
	virtual void SetUp() {
	AllocationTestHarness::SetUp();
	fragmenter =
	packet_fragmenter_get_test_interface(&controller, &allocator_malloc);

	packet_index = 0;
	data_size_sum = 0;

	callbacks.fragmented = fragmented_callback;
	callbacks.reassembled = reassembled_callback;
	callbacks.transmit_finished = transmit_finished_callback;
	controller.get_acl_data_size_classic = get_acl_data_size_classic;
	controller.get_acl_data_size_ble = get_acl_data_size_ble;

	reset_for(init);
	fragmenter->init(&callbacks);
	}

	virtual void TearDown() {
	fragmenter->cleanup();
	AllocationTestHarness::TearDown();
	}

	controller_t controller;
	packet_fragmenter_callbacks_t callbacks;
	};

	TEST_F(PacketFragmenterTest, test_no_fragment_necessary) {
	reset_for(no_fragmentation);
	BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
	small_sample_data);
	fragmenter->fragment_and_dispatch(packet);

	EXPECT_EQ(strlen(small_sample_data), data_size_sum);
	EXPECT_CALL_COUNT(fragmented_callback, 1);
	}

	TEST_F(PacketFragmenterTest, test_fragment_necessary) {
	reset_for(fragmentation);
	BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
	sample_data);
	fragmenter->fragment_and_dispatch(packet);

	EXPECT_EQ(strlen(sample_data), data_size_sum);
	}

	TEST_F(PacketFragmenterTest, test_ble_no_fragment_necessary) {
	reset_for(ble_no_fragmentation);
	BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
	small_sample_data);
	packet->event \|= LOCAL_BLE_CONTROLLER_ID;
	fragmenter->fragment_and_dispatch(packet);

	EXPECT_EQ(strlen(small_sample_data), data_size_sum);
	EXPECT_CALL_COUNT(fragmented_callback, 1);
	}

	TEST_F(PacketFragmenterTest, test_ble_fragment_necessary) {
	reset_for(ble_fragmentation);
	BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_ACL,
	sample_data);
	packet->event \|= LOCAL_BLE_CONTROLLER_ID;
	fragmenter->fragment_and_dispatch(packet);

	EXPECT_EQ(strlen(sample_data), data_size_sum);
	}

	TEST_F(PacketFragmenterTest, test_non_acl_passthrough_fragmentation) {
	reset_for(non_acl_passthrough_fragmentation);
	BT_HDR* packet = manufacture_packet_for_fragmentation(MSG_STACK_TO_HC_HCI_CMD,
	sample_data);
	fragmenter->fragment_and_dispatch(packet);

	EXPECT_EQ(strlen(sample_data), data_size_sum);
	EXPECT_CALL_COUNT(fragmented_callback, 1);
	}

	TEST_F(PacketFragmenterTest, test_no_reassembly_necessary) {
	reset_for(no_reassembly);
	manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 1337,
	small_sample_data);

	EXPECT_EQ(strlen(small_sample_data), data_size_sum);
	EXPECT_CALL_COUNT(reassembled_callback, 1);
	}

	TEST_F(PacketFragmenterTest, test_reassembly_necessary) {
	reset_for(reassembly);
	manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_ACL, 42,
	sample_data);

	EXPECT_EQ(strlen(sample_data), data_size_sum);
	EXPECT_CALL_COUNT(reassembled_callback, 1);
	}

	TEST_F(PacketFragmenterTest, test_non_acl_passthrough_reasseembly) {
	reset_for(non_acl_passthrough_reassembly);
	manufacture_packet_and_then_reassemble(MSG_HC_TO_STACK_HCI_EVT, 42,
	sample_data);

	EXPECT_EQ(strlen(sample_data), data_size_sum);
	EXPECT_CALL_COUNT(reassembled_callback, 1);
	}