mesh: fix compile warnings

src/mesh/mesh.c

@@ -1170,6 +1170,9 @@ static int mesh_node_startup_from_tlv(void){
 }
 
 static void mesh_control_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
+    UNUSED(callback_type);
+    UNUSED(status);
+
     // get opcode 
     uint8_t opcode = mesh_pdu_control_opcode(pdu);
     printf("MESH Control Message, Opcode: 0x%02x + ", opcode);

src/mesh/mesh_lower_transport.c

@@ -913,7 +913,6 @@ static void mesh_lower_transport_run(void){
 
     while(!btstack_linked_list_empty(&lower_transport_outgoing_ready)) {
         // get next message
-        mesh_network_pdu_t   * network_pdu;
         mesh_segmented_pdu_t   * message_pdu;
         mesh_pdu_t * pdu = (mesh_pdu_t *) btstack_linked_list_pop(&lower_transport_outgoing_ready);
         switch (pdu->pdu_type) {
@@ -962,7 +961,7 @@ void mesh_lower_transport_send_pdu(mesh_pdu_t *pdu){
     mesh_lower_transport_run();
 }
 
-static void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list){
+void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list){
     printf("List: %s:\n", name);
     btstack_linked_list_iterator_t it;
     btstack_linked_list_iterator_init(&it, list);
@@ -971,7 +970,8 @@ static void mesh_lower_transport_dump_network_pdus(const char *name, btstack_lin
         printf("- %p: ", network_pdu); printf_hexdump(network_pdu->data, network_pdu->len);
     }
 }
-static void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list){
+
+void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list){
     while (!btstack_linked_list_empty(list)){
         mesh_network_pdu_t * pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(list);
         btstack_memory_mesh_network_pdu_free(pdu);
@@ -1008,9 +1008,6 @@ bool mesh_lower_transport_can_send_to_dest(uint16_t dest){
 void mesh_lower_transport_reserve_slot(void){
 }
 
-void mesh_lower_transport_dump(void){
-}
-
 void mesh_lower_transport_reset(void){
     if (lower_transport_outgoing_message){
         while (!btstack_linked_list_empty(&lower_transport_outgoing_message->segments)){

src/mesh/mesh_lower_transport.h

@@ -89,8 +89,9 @@ void mesh_lower_transport_send_pdu(mesh_pdu_t * pdu);
 
 // test
 void mesh_lower_transport_received_message(mesh_network_callback_type_t callback_type, mesh_network_pdu_t *network_pdu);
-void mesh_lower_transport_dump(void);
 void mesh_lower_transport_reset(void);
+void mesh_lower_transport_dump_network_pdus(const char *name, btstack_linked_list_t *list);
+void mesh_lower_transport_reset_network_pdus(btstack_linked_list_t *list);
 
 #ifdef __cplusplus
 } /* end of extern "C" */

src/mesh/mesh_network.c

@@ -275,20 +275,6 @@ static void mesh_network_send_complete(mesh_network_pdu_t * network_pdu){
     }
 }
 
-static void mesh_network_send_d(mesh_network_pdu_t * network_pdu){
-
-#ifdef LOG_NETWORK
-    printf("TX-D-NetworkPDU (%p): ", network_pdu);
-    printf_hexdump(network_pdu->data, network_pdu->len);
-#endif
-
-    // add to queue
-    btstack_linked_list_add_tail(&network_pdus_outgoing_gatt, (btstack_linked_item_t *) network_pdu);
-
-    // go
-    mesh_network_run();
-}
-
 // new
 static void mesh_network_send_c(void *arg){
     UNUSED(arg);
@@ -1089,9 +1075,6 @@ void mesh_network_send_pdu(mesh_network_pdu_t * network_pdu){
     // go
     mesh_network_run();
 }
-static void mesh_network_encrypt_proxy_configuration_encrypted(mesh_network_pdu_t * network_pdu){
-    (*mesh_network_proxy_message_handler)(MESH_NETWORK_PDU_ENCRYPTED, network_pdu);
-}
 
 void mesh_network_encrypt_proxy_configuration_message(mesh_network_pdu_t * network_pdu){
     printf("ProxyPDU(unencrypted): ");

src/mesh/mesh_node.c

@@ -155,11 +155,11 @@ uint16_t mesh_access_get_element_address(mesh_model_t * mesh_model){
 // Model Identifier utilities
 
 uint32_t mesh_model_get_model_identifier(uint16_t vendor_id, uint16_t model_id){
-    return (vendor_id << 16) | model_id;
+    return (((uint32_t) vendor_id << 16)) | model_id;
 }
 
 uint32_t mesh_model_get_model_identifier_bluetooth_sig(uint16_t model_id){
-    return (BLUETOOTH_COMPANY_ID_BLUETOOTH_SIG_INC << 16) | model_id;
+    return ((uint32_t) BLUETOOTH_COMPANY_ID_BLUETOOTH_SIG_INC << 16) | model_id;
 }
 
 uint16_t mesh_model_get_model_id(uint32_t model_identifier){

src/mesh/mesh_upper_transport.c

@@ -384,6 +384,7 @@ static void mesh_upper_transport_process_access_message_done(mesh_access_pdu_t *
 }
 
 static void mesh_upper_transport_process_control_message_done(mesh_control_pdu_t * control_pdu){
+    UNUSED(control_pdu);
     crypto_active = 0;
     incoming_control_pdu = NULL;
     mesh_upper_transport_run();
@@ -856,8 +857,7 @@ static void mesh_upper_transport_run(void){
                     mesh_lower_transport_message_processed_by_higher_layer(pdu);
 
                     btstack_assert(mesh_control_message_handler != NULL);
-                    mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu;
+                    mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, (mesh_pdu_t*) incoming_control_pdu);
-                    mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu);
 
                 } else {
 
@@ -905,8 +905,7 @@ static void mesh_upper_transport_run(void){
                     mesh_lower_transport_message_processed_by_higher_layer((mesh_pdu_t *)segmented_pdu);
 
                     btstack_assert(mesh_control_message_handler != NULL);
-                    mesh_pdu_t * pdu = (mesh_pdu_t*) incoming_control_pdu;
+                    mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, (mesh_pdu_t*) incoming_control_pdu);
-                    mesh_control_message_handler(MESH_TRANSPORT_PDU_RECEIVED, MESH_TRANSPORT_STATUS_SUCCESS, pdu);
 
                 } else {
 
@@ -1037,7 +1036,6 @@ static mesh_upper_transport_pdu_t * mesh_upper_transport_find_and_remove_pdu_for
 
 static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
     mesh_upper_transport_pdu_t * upper_pdu;
-    mesh_network_pdu_t * network_pdu;
     mesh_segmented_pdu_t * segmented_pdu;
     switch (callback_type){
         case MESH_TRANSPORT_PDU_RECEIVED:
@@ -1052,8 +1050,8 @@ static void mesh_upper_transport_pdu_handler(mesh_transport_callback_type_t call
                     segmented_pdu = (mesh_segmented_pdu_t *) pdu;
                     // free chunks
                     while (!btstack_linked_list_empty(&segmented_pdu->segments)){
-                        mesh_network_pdu_t * network_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&segmented_pdu->segments);
+                        mesh_network_pdu_t * chunk_pdu = (mesh_network_pdu_t *) btstack_linked_list_pop(&segmented_pdu->segments);
-                        mesh_network_pdu_free(network_pdu);
+                        mesh_network_pdu_free(chunk_pdu);
                     }
                     // free segmented pdu
                     btstack_memory_mesh_segmented_pdu_free(segmented_pdu);

test/mesh/btstack_uart_block_posix_pty.c

@@ -160,6 +160,7 @@ static void hci_transport_h5_process(btstack_data_source_t *ds, btstack_data_sou
 }
 
 static int btstack_uart_posix_set_baudrate(uint32_t baudrate){
+    UNUSED(baudrate);
 #if 0
     int fd = transport_data_source.source.fd;
 

test/mesh/main.c

@@ -87,7 +87,11 @@ static hci_transport_config_uart_t config = {
 static btstack_packet_callback_registration_t hci_event_callback_registration;
 
 static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != HCI_EVENT_PACKET) return;
+
     switch (hci_event_packet_get_type(packet)){
         case BTSTACK_EVENT_STATE:
             if (btstack_event_state_get_state(packet) != HCI_STATE_WORKING) break;
@@ -125,12 +129,6 @@ static void sigint_handler(int param){
     exit(0);
 }
 
-static int led_state = 0;
-void hal_led_toggle(void){
-    led_state = 1 - led_state;
-    printf("LED State %u\n", led_state);
-}
-
 static void local_version_information_handler(uint8_t * packet){
     printf("Local version information:\n");
     uint16_t hci_version    = packet[6];

test/mesh/mesh_message_test.cpp

@@ -3,8 +3,6 @@
 #include "CppUTest/TestHarness.h"
 #include "CppUTest/CommandLineTestRunner.h"
 
-#include "bluetooth_data_types.h"
-#include "bluetooth_gatt.h"
 #include "btstack_debug.h"
 #include "btstack_memory.h"
 #include "btstack_util.h"
@@ -19,8 +17,8 @@
 #include "mesh/mesh_upper_transport.h"
 #include "mesh/provisioning.h"
 #include "mesh/mesh_peer.h"
+#include "mock.h"
 
-extern "C" int mock_process_hci_cmd(void);
 
 static mesh_network_pdu_t * received_network_pdu;
 static mesh_network_pdu_t * received_proxy_pdu;
@@ -70,6 +68,7 @@ void gatt_bearer_register_for_network_pdu(btstack_packet_handler_t packet_handle
     gatt_packet_handler = packet_handler;
 }
 void gatt_bearer_register_for_mesh_proxy_configuration(btstack_packet_handler_t packet_handler){
+    UNUSED(packet_handler);
 }
 void gatt_bearer_request_can_send_now_for_network_pdu(void){
     // simulate can send now
@@ -134,7 +133,7 @@ uint16_t mesh_pdu_ctl(mesh_pdu_t * pdu){
     }
 }
 
-void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
+static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
     int i;
     for (i=0; i<size; i++){
         if (expected[i] != actual[i]) {
@@ -147,9 +146,9 @@ void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
 }
 
 static int scan_hex_byte(const char * byte_string){
-    int upper_nibble = nibble_for_char(*byte_string++);
+    uint8_t upper_nibble = nibble_for_char(*byte_string++);
     if (upper_nibble < 0) return -1;
-    int lower_nibble = nibble_for_char(*byte_string);
+    uint8_t lower_nibble = nibble_for_char(*byte_string);
     if (lower_nibble < 0) return -1;
     return (upper_nibble << 4) | lower_nibble;
 }
@@ -161,13 +160,13 @@ static int btstack_parse_hex(const char * string, uint16_t len, uint8_t * buffer
         if (single_byte < 0) return 0;
         string += 2;
         buffer[i] = (uint8_t)single_byte;
-        // don't check seperator after last byte
+        // don't check separator after last byte
         if (i == len - 1) {
             return 1;
         }
         // optional seperator
         char separator = *string;
-        if (separator == ':' && separator == '-' && separator == ' ') {
+        if (separator == ':' || separator == '-' || separator == ' ') {
             string++;
         }
     }
@@ -269,6 +268,7 @@ static void test_proxy_server_callback_handler(mesh_network_callback_type_t call
 }
 
 static void test_upper_transport_access_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
+    UNUSED(status);
 
     // ignore pdu sent
     if (callback_type == MESH_TRANSPORT_PDU_SENT) return;
@@ -301,6 +301,8 @@ static void test_upper_transport_access_message_handler(mesh_transport_callback_
 }
 
 static void test_upper_transport_control_message_handler(mesh_transport_callback_type_t callback_type, mesh_transport_status_t status, mesh_pdu_t * pdu){
+    UNUSED(status);
+
     // ignore pdu sent
     if (callback_type == MESH_TRANSPORT_PDU_SENT) return;
 
@@ -365,7 +367,7 @@ static uint16_t transport_pdu_len;
 static     uint8_t test_network_pdu_len;
 static uint8_t test_network_pdu_data[29];
 
-void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){
+static void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_transport_pdus, char * access_pdu){
     int i;
     for (i=0;i<count;i++){
         test_network_pdu_len = strlen(network_pdus[i]) / 2;
@@ -409,7 +411,8 @@ void test_receive_network_pdus(int count, char ** network_pdus, char ** lower_tr
     CHECK_EQUAL_ARRAY(transport_pdu_data, recv_upper_transport_pdu_data, transport_pdu_len);
 }
 
-static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){
+static void expect_gatt_network_pdu(void){
+
         while (outgoing_gatt_network_pdu_len == 0) {
             mock_process_hci_cmd();
         }
@@ -425,7 +428,7 @@ static void expect_gatt_network_pdu(const uint8_t * data, uint16_t len){
         gatt_bearer_emit_sent();
 }
 
-static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){
+static void expect_adv_network_pdu(void){
         while (outgoing_adv_network_pdu_len == 0) {
             mock_process_hci_cmd();
         }
@@ -441,8 +444,9 @@ static void expect_adv_network_pdu(const uint8_t * data, uint16_t len){
         adv_bearer_emit_sent();
 }
 
-static mesh_upper_transport_pdu_t upper_pdu = { 0 };
+static void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index,  uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){
-void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index,  uint8_t ttl, uint16_t src, uint16_t dest, uint8_t szmic, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){
+
+    UNUSED(lower_transport_pdus);
 
     transport_pdu_len = strlen(control_pdu) / 2;
     btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data);
@@ -479,16 +483,18 @@ void test_send_access_message(uint16_t netkey_index, uint16_t appkey_index,  uin
         btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
 
 #ifdef ENABLE_MESH_GATT_BEARER
-        expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len);
+        expect_gatt_network_pdu();
 #endif
 
 #ifdef ENABLE_MESH_ADV_BEARER
-        expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len);
+        expect_adv_network_pdu();
 #endif
     }
 }
 
-void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){
+static void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src, uint16_t dest, char * control_pdu, int count, char ** lower_transport_pdus, char ** network_pdus){
+
+    UNUSED(lower_transport_pdus);
 
     transport_pdu_len = strlen(control_pdu) / 2;
     btstack_parse_hex(control_pdu, transport_pdu_len, transport_pdu_data);
@@ -505,9 +511,9 @@ void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src,
         mesh_upper_transport_builder_t builder;
         mesh_upper_transport_message_init(&builder, MESH_PDU_TYPE_UPPER_SEGMENTED_CONTROL);
         mesh_upper_transport_message_add_data(&builder, transport_pdu_data+1, transport_pdu_len-1);
-        mesh_upper_transport_pdu_t * upper_pdu = (mesh_upper_transport_pdu_t *) mesh_upper_transport_message_finalize(&builder);
+        mesh_upper_transport_pdu_t * final_upper_pdu = (mesh_upper_transport_pdu_t *) mesh_upper_transport_message_finalize(&builder);
-        mesh_upper_transport_setup_segmented_control_pdu_header(upper_pdu, netkey_index, ttl, src, dest, opcode);
+        mesh_upper_transport_setup_segmented_control_pdu_header(final_upper_pdu, netkey_index, ttl, src, dest, opcode);
-        pdu = (mesh_pdu_t *) upper_pdu;
+        pdu = (mesh_pdu_t *) final_upper_pdu;
     }
     mesh_upper_transport_send_control_pdu(pdu);
 
@@ -519,11 +525,11 @@ void test_send_control_message(uint16_t netkey_index, uint8_t ttl, uint16_t src,
         btstack_parse_hex(network_pdus[i], test_network_pdu_len, test_network_pdu_data);
 
 #ifdef ENABLE_MESH_GATT_BEARER
-        expect_gatt_network_pdu(test_network_pdu_data, test_network_pdu_len);
+        expect_gatt_network_pdu();
 #endif
 
 #ifdef ENABLE_MESH_ADV_BEARER
-        expect_adv_network_pdu(test_network_pdu_data, test_network_pdu_len);
+        expect_adv_network_pdu();
 #endif
 
     }
@@ -1187,6 +1193,7 @@ TEST(MessageTest, ServiceDataUsingNodeIdentityTest){
 static btstack_crypto_aes128_cmac_t aes_cmac_request;
 static uint8_t k4_result[1];
 static void handle_k4_result(void *arg){
+    UNUSED(arg);
     printf("ApplicationkeyIDTest: %02x\n", k4_result[0]);
     CHECK_EQUAL( 0x26, k4_result[0]);
 }

test/mesh/mesh_pts.c

@@ -90,8 +90,6 @@ static const char * prov_public_key_string = "F465E43FF23D3F1B9DC7DFC04DA8758184
 static uint8_t      prov_private_key_data[32];
 static const char * prov_private_key_string = "529AA0670D72CD6497502ED473502B037E8803B5C60829A5A3CAA219505530BA";
 
-static mesh_transport_key_t pts_application_key;
-
 // pin entry (pts)
 static int ui_chars_for_pin; 
 static uint8_t ui_pin[17];
@@ -154,6 +152,10 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
 }
 
 static void mesh_provisioning_message_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(packet_type);
+    UNUSED(channel);
+    UNUSED(size);
+
     mesh_provisioning_data_t provisioning_data;
 
     switch(packet[0]){
@@ -204,6 +206,9 @@ static void mesh_provisioning_message_handler (uint8_t packet_type, uint16_t cha
 }
 
 static void mesh_state_update_message_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != HCI_EVENT_PACKET) return;
    
     switch(packet[0]){
@@ -227,6 +232,9 @@ static void mesh_state_update_message_handler(uint8_t packet_type, uint16_t chan
 }
 
 static void mesh_configuration_message_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != HCI_EVENT_PACKET) return;
    
     switch(packet[0]){
@@ -243,48 +251,6 @@ static void mesh_configuration_message_handler(uint8_t packet_type, uint16_t cha
 }
 // PTS
 
-// helper network layer, temp
-static void mesh_pts_received_network_message(mesh_network_callback_type_t callback_type, mesh_network_pdu_t *network_pdu){
-    switch (callback_type){
-        case MESH_NETWORK_PDU_RECEIVED:
-            printf("Received network message. SRC %04x, DST %04x, SEQ %04x\n",
-                   mesh_network_src(network_pdu), mesh_network_dst(network_pdu),  mesh_network_seq(network_pdu));
-            printf_hexdump(mesh_network_pdu_data(network_pdu), mesh_network_pdu_len(network_pdu));
-            mesh_network_message_processed_by_higher_layer(network_pdu);
-            break;
-        default:
-            break;
-    }
-}
-
-static uint8_t mesh_network_send(uint8_t ttl, uint16_t dest, const uint8_t * transport_pdu_data, uint8_t transport_pdu_len){
-
-    uint16_t netkey_index = 0;
-    uint8_t  ctl = 0;
-    uint16_t src = mesh_node_get_primary_element_address();
-    uint32_t seq = mesh_sequence_number_next();
-
-    // "3.4.5.2: The output filter of the interface connected to advertising or GATT bearers shall drop all messages with TTL value set to 1."
-    // if (ttl <= 1) return 0;
-
-    // TODO: check transport_pdu_len depending on ctl
-
-    // lookup network by netkey_index
-    const mesh_network_key_t * network_key = mesh_network_key_list_get(netkey_index);
-    if (!network_key) return 0;
-
-    // allocate network_pdu
-    mesh_network_pdu_t * network_pdu = mesh_network_pdu_get();
-    if (!network_pdu) return 0;
-
-    // setup network_pdu
-    mesh_network_setup_pdu(network_pdu, netkey_index, network_key->nid, ctl, ttl, seq, src, dest, transport_pdu_data, transport_pdu_len);
-
-    // send network_pdu
-    mesh_lower_transport_send_pdu((mesh_pdu_t *) network_pdu);
-    return 0;
-}
-
 static void printf_hex(const uint8_t * data, uint16_t len){
     while (len){
         printf("%02x", *data);
@@ -323,6 +289,9 @@ static void mesh_pts_dump_mesh_options(void){
 }
 
 static void mesh_unprovisioned_beacon_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != MESH_BEACON_PACKET) return;
     static uint8_t  device_uuid[16];
     uint16_t oob;
@@ -372,16 +341,6 @@ static void btstack_print_hex(const uint8_t * data, uint16_t len, char separator
     printf("\n");
 }
 
-static void load_pts_tspx_application_key(void){
-    // PTS app key
-    btstack_parse_hex("3216D1509884B533248541792B877F98", 16, pts_application_key.key);
-    pts_application_key.aid = 0x38;
-    pts_application_key.internal_index = mesh_transport_key_get_free_index();
-    mesh_transport_key_add(&pts_application_key);
-    printf("PTS Application Key (AID %02x): ", 0x38);
-    printf_hexdump(pts_application_key.key, 16);
-}
-
 static void send_pts_network_messsage(uint16_t dst_addr, uint8_t ttl){
     uint8_t access_pdu_data[16];
 

test/mesh/mock.c

@@ -1,6 +1,7 @@
+
+#include "mock.h"
+
 #include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
 #include <string.h>
 
 #include "ble/att_db.h"
@@ -48,10 +49,14 @@ static void dump_packet(int packet_type, uint8_t * buffer, uint16_t size){
 	}
 	printf("};\n");
 	packet_counter++;
+#else
+UNUSED(packet_type);
+UNUSED(buffer);
+UNUSED(size);
 #endif
 }
 
-void aes128_calc_cyphertext(uint8_t key[16], uint8_t plaintext[16], uint8_t cyphertext[16]){
+static void aes128_calc_cyphertext(uint8_t key[16], uint8_t plaintext[16], uint8_t cyphertext[16]){
 	uint32_t rk[RKLENGTH(KEYBITS)];
 	int nrounds = rijndaelSetupEncrypt(rk, &key[0], KEYBITS);
 	rijndaelEncrypt(rk, nrounds, plaintext, cyphertext);
@@ -152,19 +157,27 @@ HCI_STATE hci_get_state(void){
 }
 
 void btstack_run_loop_add_timer(btstack_timer_source_t * ts){
+    UNUSED(ts);
 }
 int btstack_run_loop_remove_timer(btstack_timer_source_t * ts){
+    UNUSED(ts);
 	return 0;
 }
 void btstack_run_loop_set_timer(btstack_timer_source_t * ts, uint32_t timeout){
+    UNUSED(ts);
+    UNUSED(timeout);
 }
 void btstack_run_loop_set_timer_handler(btstack_timer_source_t * ts, void (*fn)(btstack_timer_source_t * ts)){
+    UNUSED(ts);
+    UNUSED(fn);
 }
 static void * timer_context;
 void btstack_run_loop_set_timer_context(btstack_timer_source_t * ts, void * context){
+    UNUSED(ts);
 	timer_context = context;
 }
 void * btstack_run_loop_get_timer_context(btstack_timer_source_t * ts){
+    UNUSED(ts);
 	return timer_context;
 }
 void hci_halting_defer(void){

test/mesh/mock.h

@@ -0,0 +1,59 @@
+/*
+ * Copyright (C) 2018 BlueKitchen GmbH
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the copyright holders nor the names of
+ *    contributors may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ * 4. Any redistribution, use, or modification is done solely for
+ *    personal benefit and not for any commercial purpose or for
+ *    monetary gain.
+ *
+ * THIS SOFTWARE IS PROVIDED BY BLUEKITCHEN GMBH AND CONTRIBUTORS
+ * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL MATTHIAS
+ * RINGWALD OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
+ * THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * Please inquire about commercial licensing options at
+ * contact@bluekitchen-gmbh.com
+ *
+ */
+
+#ifndef __MOCK_H
+#define __MOCK_H
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+
+#include <stdint.h>
+
+void mock_init(void);
+uint8_t * mock_packet_buffer(void);
+void mock_clear_packet_buffer(void);
+void mock_simulate_hci_event(uint8_t * packet, uint16_t size);
+int mock_process_hci_cmd(void);
+void mock_simulate_hci_state_working(void);
+
+#ifdef __cplusplus
+} /* end of extern "C" */
+#endif
+
+#endif

test/mesh/provisioner.c

@@ -147,6 +147,9 @@ static void packet_handler (uint8_t packet_type, uint16_t channel, uint8_t *pack
 }
 
 static void mesh_message_handler (uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != HCI_EVENT_PACKET) return;
 
     uint8_t public_oob  = 0;
@@ -240,7 +243,11 @@ static void mesh_message_handler (uint8_t packet_type, uint16_t channel, uint8_t
 static uint8_t device_uuid[16];
 
 static void mesh_unprovisioned_beacon_handler(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
+
     if (packet_type != MESH_BEACON_PACKET) return;
+
     uint16_t oob;
     memcpy(device_uuid, &packet[1], 16);
     oob = big_endian_read_16(packet, 17);

test/mesh/provisioning_device_test.cpp

@@ -37,8 +37,7 @@
 
 #include <stdint.h>
 #include <stdio.h>
-#include <stdlib.h>
+#include "btstack_memory.h"
-#include <string.h>
 #include "ble/gatt-service/mesh_provisioning_service_server.h"
 #include "hci_dump.h"
 #include "mesh/mesh_node.h"
@@ -50,6 +49,8 @@
 #include "CppUTest/TestHarness.h"
 #include "CppUTest/CommandLineTestRunner.h"
 
+#include "mock.h"
+
 static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
     int i;
     for (i=0; i<size; i++){
@@ -62,37 +63,6 @@ static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
     }
 }
 
-void dump_data(uint8_t * buffer, uint16_t size){
-    static int data_counter = 1;
-    char var_name[80];
-    sprintf(var_name, "test_data_%02u", data_counter);
-    printf("uint8_t %s[] = { ", var_name);
-    for (int i = 0; i < size ; i++){
-        if ((i % 16) == 0) printf("\n    ");
-        printf ("0x%02x, ", buffer[i]);
-    }
-    printf("};\n");
-    data_counter++;
-}
-
-int parse_hex(uint8_t * buffer, const char * hex_string){
-    int len = 0;
-    while (*hex_string){
-        if (*hex_string == ' '){
-            hex_string++;
-            continue;
-        }
-        int high_nibble = nibble_for_char(*hex_string++);
-        int low_nibble = nibble_for_char(*hex_string++);
-        *buffer++ = (high_nibble << 4) | low_nibble;
-        len++;
-    }
-    return len;
-}
-
-// returns if anything was done
-extern "C" int mock_process_hci_cmd(void);
-
 const static uint8_t device_uuid[] = { 0x00, 0x1B, 0xDC, 0x08, 0x10, 0x21, 0x0B, 0x0E, 0x0A, 0x0C, 0x00, 0x0B, 0x0E, 0x0A, 0x0C, 0x00 };
 
 // pb-adv mock for testing
@@ -114,8 +84,14 @@ void pb_gatt_init(void){}
  * @param con_handle
  * @param reason 0 = success, 1 = timeout, 2 = fail
  */
-void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){}
+void pb_gatt_close_link(hci_con_handle_t con_handle, uint8_t reason){
-void pb_adv_close_link(hci_con_handle_t con_handle, uint8_t reason){}
+    UNUSED(con_handle);
+    UNUSED(reason);
+}
+void pb_adv_close_link(hci_con_handle_t con_handle, uint8_t reason){
+    UNUSED(con_handle);
+    UNUSED(reason);
+}
 
 
 /**
@@ -138,7 +114,11 @@ void pb_adv_send_pdu(uint16_t pb_transport_cid, const uint8_t * pdu, uint16_t si
     // dump_data((uint8_t*)pdu,size);
     // printf_hexdump(pdu, size);
 }
-void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t pdu_size){}
+void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t _pdu_size){
+    UNUSED(con_handle);
+    UNUSED(pdu);
+    UNUSED(_pdu_size);
+}
  
 uint16_t mesh_network_key_get_free_index(void){
     return 0;

test/mesh/provisioning_provisioner_test.cpp

@@ -45,6 +45,7 @@
 #include "mesh/provisioning.h"
 #include "mesh/provisioning_provisioner.h"
 #include "hci_dump.h"
+#include "mock.h"
 
 #include "CppUTest/TestHarness.h"
 #include "CppUTest/CommandLineTestRunner.h"
@@ -61,37 +62,6 @@ static void CHECK_EQUAL_ARRAY(uint8_t * expected, uint8_t * actual, int size){
     }
 }
 
-void dump_data(uint8_t * buffer, uint16_t size){
-    static int data_counter = 1;
-    char var_name[80];
-    sprintf(var_name, "test_data_%02u", data_counter);
-    printf("uint8_t %s[] = { ", var_name);
-    for (int i = 0; i < size ; i++){
-        if ((i % 16) == 0) printf("\n    ");
-        printf ("0x%02x, ", buffer[i]);
-    }
-    printf("};\n");
-    data_counter++;
-}
-
-int parse_hex(uint8_t * buffer, const char * hex_string){
-    int len = 0;
-    while (*hex_string){
-        if (*hex_string == ' '){
-            hex_string++;
-            continue;
-        }
-        int high_nibble = nibble_for_char(*hex_string++);
-        int low_nibble = nibble_for_char(*hex_string++);
-        *buffer++ = (high_nibble << 4) | low_nibble;
-        len++;
-    }
-    return len;
-}
-
-// returns if anything was done
-extern "C" int mock_process_hci_cmd(void);
-
 // pb-adv mock for testing
 
 static btstack_packet_handler_t pb_adv_packet_handler;
@@ -114,7 +84,10 @@ static void pb_adv_emit_pdu_sent(uint8_t status){
 void pb_adv_init(void){}
 void pb_gatt_init(void){}
 
-void pb_adv_close_link(uint16_t pb_adv_cid, uint8_t reason){}
+void pb_adv_close_link(uint16_t pb_adv_cid, uint8_t reason){
+    UNUSED(pb_adv_cid);
+    UNUSED(reason);
+}
 
 void pb_adv_register_provisioner_packet_handler(btstack_packet_handler_t packet_handler){
     pb_adv_packet_handler = packet_handler;
@@ -131,9 +104,14 @@ void pb_adv_send_pdu(uint16_t pb_transport_cid, const uint8_t * pdu, uint16_t si
     // dump_data((uint8_t*)pdu,size);
     // printf_hexdump(pdu, size);
 }
-void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t pdu_size){}
+void pb_gatt_send_pdu(uint16_t con_handle, const uint8_t * pdu, uint16_t _pdu_size){
+    UNUSED(con_handle);
+    UNUSED(pdu);
+    UNUSED(_pdu_size);
+}
 
 uint16_t pb_adv_create_link(const uint8_t * device_uuid){
+    UNUSED(device_uuid);
     // just simluate opened
     pb_adv_emit_link_open(0, 1);
     return 1;
@@ -185,6 +163,8 @@ static uint8_t      prov_static_oob_data[16];
 static const char * prov_static_oob_string = "00000000000000000102030405060708";
 
 static void provisioning_handle_pdu(uint8_t packet_type, uint16_t channel, uint8_t *packet, uint16_t size){
+    UNUSED(channel);
+    UNUSED(size);
     if (packet_type != HCI_EVENT_PACKET) return;
     switch(packet[0]){
         case HCI_EVENT_MESH_META: