FHSS unit tests: Test failed TX allocation

Jarkko Paso · Jarkko Paso · commit b28fcaa10809 · 2018-04-13T14:49:35.000+03:00
diff --git a/source/Service_Libs/fhss/fhss_common.c b/source/Service_Libs/fhss/fhss_common.c
@@ -287,7 +287,7 @@ int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle, uin
 {
     fhss_failed_tx_t *failed_tx = ns_dyn_mem_alloc(sizeof(fhss_failed_tx_t));
     if (!failed_tx) {
-        return -2;
+        return -1;
     }
     failed_tx->bad_channel = bad_channel;
     failed_tx->retries_done = 0;
diff --git a/source/Service_Libs/fhss/fhss_ws.c b/source/Service_Libs/fhss/fhss_ws.c
@@ -294,9 +294,6 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a
 
 static bool fhss_check_bad_channel(fhss_structure_t *fhss_structure, uint8_t handle)
 {
-    if (!fhss_structure) {
-        return false;
-    }
     fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle);
     if (!failed_tx) {
         return true;
diff --git a/test/nanostack/unittest/service_libs/fhss/test_fhss.c b/test/nanostack/unittest/service_libs/fhss/test_fhss.c
@@ -129,7 +129,6 @@ static fhss_api_t *test_generate_fhss_api(void)
     memset(&fhss_channel_stub, 0, sizeof(fhss_channel_stub_def));
     FHSS.fhss_api = &fhss_api;
     FHSS.bs = &bs;
-    ns_list_init(&FHSS.fhss_failed_tx_list);
     FHSS.callbacks.change_channel = &mac_set_channel;
     FHSS.callbacks.read_mac_address = &mac_read_64bit_mac_address;
     FHSS.callbacks.read_datarate = &mac_read_phy_datarate;
@@ -138,7 +137,6 @@ static fhss_api_t *test_generate_fhss_api(void)
     FHSS.callbacks.synch_lost_notification = &mac_synch_lost;
     FHSS.callbacks.broadcast_notify = &mac_broadcast_notification;
     test_set_fhss_default_configs();
-    ns_list_init(&FHSS.fhss_failed_tx_list);
     test_set_platform_api(&FHSS.platform_functions);
     fhss_set_callbacks(&FHSS);
     return &fhss_api;
diff --git a/test/nanostack/unittest/service_libs/fhss_common/fhsscommontest.cpp b/test/nanostack/unittest/service_libs/fhss_common/fhsscommontest.cpp
@@ -90,3 +90,13 @@ TEST(fhss_common, test_fhss_clear_active_event)
 {
     CHECK(test_fhss_clear_active_event());
 }
+
+TEST(fhss_common, test_fhss_failed_handle_add)
+{
+    CHECK(test_fhss_failed_handle_add());
+}
+
+TEST(fhss_common, test_fhss_failed_list_free)
+{
+    CHECK(test_fhss_failed_list_free());
+}
diff --git a/test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.c b/test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.c
@@ -17,6 +17,9 @@
 #include "fhss_platform_stub.h"
 #include "fhss_callbacks_stub.h"
 
+#define DEFAULT_BAD_CHANNEL 10
+#define DEFAULT_HANDLE      1
+
 static fhss_api_t fhss_api;
 static fhss_timer_t fhss_timer;
 static fhss_structure_t fhss_structure;
@@ -314,3 +317,53 @@ bool test_fhss_clear_active_event()
     }
     return true;
 }
+
+bool test_fhss_failed_handle_add()
+{
+    ns_list_init(&fhss_structure.fhss_failed_tx_list);
+    // Test without memory
+    if (fhss_failed_handle_add(&fhss_structure, DEFAULT_HANDLE, DEFAULT_BAD_CHANNEL) != -1) {
+        return false;
+    }
+    // Test success
+    nsdynmemlib_stub.returnCounter = 1;
+    if (fhss_failed_handle_add(&fhss_structure, DEFAULT_HANDLE, DEFAULT_BAD_CHANNEL) != 0) {
+        return false;
+    }
+    // Test finding using invalid handle
+    if (fhss_failed_handle_find(&fhss_structure, DEFAULT_HANDLE+1) != NULL) {
+        return false;
+    }
+    // Test finding
+    if (fhss_failed_handle_find(&fhss_structure, DEFAULT_HANDLE) == NULL) {
+        return false;
+    }
+    // Remove entry using invalid handle
+    if (fhss_failed_handle_remove(&fhss_structure, 0) != -1) {
+        return false;
+    }
+    // Remove entry
+    if (fhss_failed_handle_remove(&fhss_structure, DEFAULT_HANDLE) != 0) {
+        return false;
+    }
+
+    return true;
+}
+
+bool test_fhss_failed_list_free()
+{
+    ns_list_init(&fhss_structure.fhss_failed_tx_list);
+
+    // Add some entries
+    uint8_t number_of_entries = 10;
+    nsdynmemlib_stub.returnCounter = number_of_entries;
+    for (int i=0; i<number_of_entries; i++) {
+        if (fhss_failed_handle_add(&fhss_structure, DEFAULT_HANDLE+i, DEFAULT_BAD_CHANNEL+i) != 0) {
+            return false;
+        }
+    }
+    // Remove entries;
+    fhss_failed_list_free(&fhss_structure);
+
+    return true;
+}
diff --git a/test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.h b/test/nanostack/unittest/service_libs/fhss_common/test_fhss_common.h
@@ -25,6 +25,8 @@ bool test_fhss_use_broadcast_queue_cb();
 bool test_fhss_read_timestamp_cb();
 bool test_fhss_init_callbacks_cb();
 bool test_fhss_clear_active_event();
+bool test_fhss_failed_handle_add();
+bool test_fhss_failed_list_free();
 
 #ifdef __cplusplus
 }
diff --git a/test/nanostack/unittest/service_libs/fhss_ws/test_fhss_ws.c b/test/nanostack/unittest/service_libs/fhss_ws/test_fhss_ws.c
@@ -141,6 +141,7 @@ static fhss_api_t *test_generate_fhss_api(void)
     fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
     fhss_common_stub.fhss_struct.callbacks.change_channel = &mac_set_channel;
     fhss_common_stub.fhss_struct.callbacks.read_mac_address = &mac_read_64bit_mac_address;
+    fhss_common_stub.fhss_struct.callbacks.read_tx_queue_size = &mac_read_tx_queue_sizes;
     fhss_common_stub.fhss_struct.callbacks.tx_poll = &mac_poll_tx_queue;
     test_set_platform_api(&fhss_common_stub.fhss_struct.platform_functions);
     fhss_ws_set_callbacks(&fhss_common_stub.fhss_struct);
@@ -306,6 +307,19 @@ bool test_fhss_ws_check_tx_conditions_callback()
     if (fhss_common_stub.fhss_struct.fhss_api->check_tx_conditions(api, true, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH) != true) {
         return false;
     }
+    // Test bad channel and failed handle not found
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_failed_tx.handle = DEFAULT_HANDLE+1;
+    if (fhss_common_stub.fhss_struct.fhss_api->check_tx_conditions(api, DEFAULT_IS_BC_DEST, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH) != true) {
+        return false;
+    }
+    // Test when on bad channel
+    fhss_common_stub.fhss_struct.ws->is_on_bc_channel = false;
+    fhss_common_stub.fhss_failed_tx.handle = DEFAULT_HANDLE;
+    fhss_common_stub.fhss_failed_tx.bad_channel = fhss_common_stub.fhss_struct.rx_channel;
+    if (fhss_common_stub.fhss_struct.fhss_api->check_tx_conditions(api, DEFAULT_IS_BC_DEST, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE, DEFAULT_FRAME_LENGTH, DEFAULT_PHY_HEAD_LENGTH, DEFAULT_PHY_TAIL_LENGTH) != false) {
+        return false;
+    }
 
     return true;
 }
@@ -345,11 +359,32 @@ bool test_fhss_ws_data_tx_fail_callback()
     if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != false) {
         return false;
     }
-    // Test when FHSS struct can be found
+    // Test when FHSS is unsynchronized
     enable_fhss_struct();
     if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != false) {
         return false;
     }
+    // Test when not data frame
+    fhss_common_stub.fhss_struct.fhss_state = FHSS_SYNCHRONIZED;
+    if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, FHSS_SYNCH_FRAME) != false) {
+        return false;
+    }
+    // Test adding new failed entry
+    fhss_common_stub.fhss_failed_tx.handle = DEFAULT_HANDLE+1;
+    fhss_common_stub.fhss_failed_tx.retries_done = 0;
+    if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != true) {
+        return false;
+    }
+    // Test when handle failed again
+    fhss_common_stub.fhss_failed_tx.handle = DEFAULT_HANDLE;
+    if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != true) {
+        return false;
+    }
+    // Test last failure
+    fhss_common_stub.fhss_failed_tx.retries_done = 3;
+    if (fhss_common_stub.fhss_struct.fhss_api->data_tx_fail(api, DEFAULT_HANDLE, DEFAULT_FRAME_TYPE) != false) {
+        return false;
+    }
 
     return true;
 }
diff --git a/test/nanostack/unittest/stub/fhss_common_stub.c b/test/nanostack/unittest/stub/fhss_common_stub.c
@@ -128,6 +128,9 @@ int fhss_init_callbacks_cb(const fhss_api_t *api, fhss_callback_t *callbacks)
 
 fhss_failed_tx_t *fhss_failed_handle_find(fhss_structure_t *fhss_structure, uint8_t handle)
 {
+    if (fhss_common_stub.fhss_failed_tx.handle == handle) {
+        return &fhss_common_stub.fhss_failed_tx;
+    }
     return NULL;
 }
 
diff --git a/test/nanostack/unittest/stub/fhss_common_stub.h b/test/nanostack/unittest/stub/fhss_common_stub.h
@@ -27,6 +27,7 @@ typedef struct {
     bool bool_value;
     uint32_t uint32_value;
     fhss_structure_t fhss_struct;
+    fhss_failed_tx_t fhss_failed_tx;
     void (*callback[2])(const fhss_api_t *fhss_api, uint16_t);
 } fhss_common_stub_def;
 

Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ int fhss_failed_handle_add(fhss_structure_t *fhss_structure, uint8_t handle, uin`
`287`	`287`	`{`
`288`	`288`	`fhss_failed_tx_t *failed_tx = ns_dyn_mem_alloc(sizeof(fhss_failed_tx_t));`
`289`	`289`	`if (!failed_tx) {`
`290`		`- return -2;`
	`290`	`+ return -1;`
`291`	`291`	`}`
`292`	`292`	`failed_tx->bad_channel = bad_channel;`
`293`	`293`	`failed_tx->retries_done = 0;`
Original file line number	Diff line number	Diff line change
`@@ -294,9 +294,6 @@ static int fhss_ws_tx_handle_callback(const fhss_api_t *api, bool is_broadcast_a`
`294`	`294`
`295`	`295`	`static bool fhss_check_bad_channel(fhss_structure_t *fhss_structure, uint8_t handle)`
`296`	`296`	`{`
`297`		`- if (!fhss_structure) {`
`298`		`- return false;`
`299`		`- }`
`300`	`297`	`fhss_failed_tx_t *failed_tx = fhss_failed_handle_find(fhss_structure, handle);`
`301`	`298`	`if (!failed_tx) {`
`302`	`299`	`return true;`
Original file line number	Diff line number	Diff line change
`@@ -90,3 +90,13 @@ TEST(fhss_common, test_fhss_clear_active_event)`
`90`	`90`	`{`
`91`	`91`	`CHECK(test_fhss_clear_active_event());`
`92`	`92`	`}`
	`93`	`+`
	`94`	`+TEST(fhss_common, test_fhss_failed_handle_add)`
	`95`	`+{`
	`96`	`+ CHECK(test_fhss_failed_handle_add());`
	`97`	`+}`
	`98`	`+`
	`99`	`+TEST(fhss_common, test_fhss_failed_list_free)`
	`100`	`+{`
	`101`	`+ CHECK(test_fhss_failed_list_free());`
	`102`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -25,6 +25,8 @@ bool test_fhss_use_broadcast_queue_cb();`
`25`	`25`	`bool test_fhss_read_timestamp_cb();`
`26`	`26`	`bool test_fhss_init_callbacks_cb();`
`27`	`27`	`bool test_fhss_clear_active_event();`
	`28`	`+bool test_fhss_failed_handle_add();`
	`29`	`+bool test_fhss_failed_list_free();`
`28`	`30`
`29`	`31`	`#ifdef __cplusplus`
`30`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,9 @@ int fhss_init_callbacks_cb(const fhss_api_t api, fhss_callback_t callbacks)`
`128`	`128`
`129`	`129`	`fhss_failed_tx_t fhss_failed_handle_find(fhss_structure_t fhss_structure, uint8_t handle)`
`130`	`130`	`{`
	`131`	`+ if (fhss_common_stub.fhss_failed_tx.handle == handle) {`
	`132`	`+ return &fhss_common_stub.fhss_failed_tx;`
	`133`	`+ }`
`131`	`134`	`return NULL;`
`132`	`135`	`}`
`133`	`136`