--- /dev/null
+/*
+ test_cases_get_node_reachability.c -- Execution of specific meshlink black box test cases
+ Copyright (C) 2019 Guus Sliepen <guus@meshlink.io>
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along
+ with this program; if not, write to the Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+*/
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <setjmp.h>
+#include <cmocka.h>
+#include <pthread.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <sys/wait.h>
+#include <signal.h>
+#include <sys/stat.h>
+#include <unistd.h>
+#include <utime.h>
+#include "execute_tests.h"
+#include "test_cases_get_node_reachability.h"
+#include "../common/test_step.h"
+#include "../common/common_handlers.h"
+#include "../../utils.h"
+
+#define NUT "nut"
+#define PEER "peer"
+#define PEER2 "peer2"
+#define GET_NODE_REACHABILITY "test_get_node_reachability"
+#define create_path(confbase, node_name, test_case_no) assert(snprintf(confbase, sizeof(confbase), GET_NODE_REACHABILITY "_%ld_%s_%02d", (long) getpid(), node_name, test_case_no) > 0)
+
+static struct sync_flag peer_reachable_status_cond = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cond = PTHREAD_COND_INITIALIZER};
+static bool peer_reachable_status;
+static struct sync_flag nut_reachable_status_cond = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cond = PTHREAD_COND_INITIALIZER};
+static bool nut_reachable_status;
+static struct sync_flag nut_started_status_cond = {.mutex = PTHREAD_MUTEX_INITIALIZER, .cond = PTHREAD_COND_INITIALIZER};
+static bool peer_node_callback_test_status;
+
+static void test_case_get_node_reachability_01(void **state);
+static bool test_get_node_reachability_01(void);
+static void test_case_get_node_reachability_02(void **state);
+static bool test_get_node_reachability_02(void);
+static void test_case_get_node_reachability_03(void **state);
+static bool test_get_node_reachability_03(void);
+static void test_case_get_node_reachability_04(void **state);
+static bool test_get_node_reachability_04(void);
+static void test_case_get_node_reachability_05(void **state);
+static bool test_get_node_reachability_05(void);
+static void test_case_get_node_reachability_06(void **state);
+static bool test_get_node_reachability_06(void);
+static void test_case_get_node_reachability_07(void **state);
+static bool test_get_node_reachability_07(void);
+
+/* Node reachable status callback which signals the respective conditional varibale */
+static void meshlink_node_reachable_status_cb(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable_status) {
+ if(!strcasecmp(mesh->name, NUT)) {
+ if(!strcasecmp(node->name, PEER)) {
+ peer_reachable_status = reachable_status;
+ set_sync_flag(&peer_reachable_status_cond, true);
+ }
+ } else if(!strcasecmp(mesh->name, PEER)) {
+ if(!strcasecmp(node->name, NUT)) {
+ nut_reachable_status = reachable_status;
+ set_sync_flag(&nut_reachable_status_cond, true);
+ }
+ }
+}
+
+static void meshlink_node_reachable_status_cb_2(meshlink_handle_t *mesh, meshlink_node_t *node, bool reachable_status) {
+ meshlink_node_t *peer_handle;
+ char *peer_name = NULL;
+ time_t last_unreachable, last_reachable;
+ static int count = 2;
+
+ if(meshlink_get_self(mesh) == node) {
+ return;
+ }
+
+ /* Of the 2 node reachable callbacks, the latest callback calls meshlink_get_node_reachability API
+ for the 1st node joined */
+ if(count && reachable_status && !strcasecmp(mesh->name, NUT)) {
+ --count;
+
+ if(!count) {
+ if(!strcasecmp(node->name, PEER)) {
+ peer_name = PEER2;
+ } else if(!strcasecmp(node->name, PEER2)) {
+ peer_name = PEER;
+ }
+
+ peer_handle = meshlink_get_node(mesh, peer_name);
+ assert_non_null(peer_handle);
+
+ bool status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+
+ peer_node_callback_test_status = status && last_reachable && !last_unreachable;
+ set_sync_flag(&peer_reachable_status_cond, true);
+ }
+ }
+}
+
+/* SIGUSR2 signal handler that signals the NUT started and PEER node can join */
+void nut_started_user_signal_handler(int signum) {
+ if(signum == SIGUSR2) {
+ set_sync_flag(&nut_started_status_cond, true);
+ }
+
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 1 -
+ Sanity API test
+*/
+static void test_case_get_node_reachability_01(void **state) {
+ execute_test(test_get_node_reachability_01, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 1
+
+ Test steps and scenarios:
+ 1. Open Node-Under-Test (NUT) instance, Call meshlink_get_node_reachability API
+ with valid mesh handle, self node handle, last_reachable pointer and
+ last_unreachable pointer.
+ Expected Result:
+ API returns self node unreachable, last_reachable and last_unreachable values
+ as 0 seconds
+
+ 2. Call meshlink_get_node_reachability API with valid mesh handle, self node handle.
+ But pass NULL pointers for last_reachable and last_unreachable arguments
+ Expected Result:
+ API returns self node unreachable
+
+ 3. Call meshlink_get_node_reachability API with NULL as mesh handle,
+ valid self node handle, last_reachable pointer and last_unreachable pointer.
+ Expected Result:
+ API fails and sets MESHLINK_EINVAL as meshlink errno value
+
+ 4. Call meshlink_get_node_reachability API with NULL as mesh handle,
+ valid self node handle, NULL pointers for last_reachable and last_unreachable
+ arguments
+ Expected Result:
+ API fails and sets MESHLINK_EINVAL as meshlink errno value
+
+ 5. Call meshlink_get_node_reachability API with valid mesh handle,
+ NULL as self node handle, last_reachable pointer and last_unreachable pointer.
+ Expected Result:
+ API fails and sets MESHLINK_EINVAL as meshlink errno value
+
+ 6. Call meshlink_get_node_reachability API with valid mesh handle,
+ NULL as self node handle, NULL pointers for last_reachable and last_unreachable
+ arguments
+ Expected Result:
+ API fails and sets MESHLINK_EINVAL as meshlink errno value
+
+*/
+static bool test_get_node_reachability_01(void) {
+ bool status;
+ time_t last_unreachable, last_reachable;
+ char nut_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 1);
+
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open Node-Under-Test node instance
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_int_not_equal(mesh, NULL);
+
+ // Call meshlink_get_node_reachability API with all valid arguments
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_self(mesh), &last_reachable, &last_unreachable);
+ assert_int_equal(status, false);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Call meshlink_get_node_reachability API with all valid arguments
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_self(mesh), NULL, NULL);
+ assert_int_equal(status, false);
+
+ // Call meshlink_get_node_reachability API with invalid parameters
+
+ meshlink_errno = MESHLINK_OK;
+ meshlink_get_node_reachability(NULL, meshlink_get_self(mesh), NULL, NULL);
+ assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
+ meshlink_errno = MESHLINK_OK;
+ meshlink_get_node_reachability(NULL, meshlink_get_self(mesh), &last_reachable, &last_unreachable);
+ assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
+ meshlink_errno = MESHLINK_OK;
+ meshlink_get_node_reachability(mesh, NULL, NULL, NULL);
+ assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
+ meshlink_errno = MESHLINK_OK;
+ meshlink_get_node_reachability(mesh, NULL, &last_reachable, &last_unreachable);
+ assert_int_equal(meshlink_errno, MESHLINK_EINVAL);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ assert_true(meshlink_destroy(nut_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 2 -
+ API testing with stand-alone node
+*/
+static void test_case_get_node_reachability_02(void **state) {
+ execute_test(test_get_node_reachability_02, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 2
+
+ Test steps and scenarios:
+ 1. Open and start Node-Under-Test (NUT) instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns self node reachable status, last_reachable as some positive non-zero integer
+ and last_unreachable value as 0 seconds
+
+ 2. Stop the NUT instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns self node unreachable, both last_reachable and last_unreachable values
+ as some positive non-zero time in seconds
+
+ 3. Close and reopen NUT instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns self node unreachable, both last_reachable and last_unreachable values
+ as some positive non-zero time in seconds
+
+*/
+static bool test_get_node_reachability_02(void) {
+ bool status;
+ time_t last_unreachable, last_reachable, last_peer_unreachable, last_peer_reachable;
+ char nut_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 2);
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open and start Node-Under-Test node instance
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ assert_true(meshlink_start(mesh));
+
+ // Call meshlink_get_node_reachability API with all valid arguments
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_self(mesh), &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+ last_peer_reachable = last_reachable;
+
+ // Stop NUT node instance
+
+ meshlink_stop(mesh);
+
+ // Call meshlink_get_node_reachability API with all valid arguments
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_self(mesh), &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_not_equal(last_unreachable, 0);
+ assert_int_equal(last_reachable, last_peer_reachable);
+ last_peer_unreachable = last_unreachable;
+
+ // Reinitialize NUT node instance
+
+ meshlink_close(mesh);
+ mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+
+ // Call meshlink_get_node_reachability API with all valid arguments
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_self(mesh), &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, last_peer_reachable);
+ assert_int_equal(last_unreachable, last_peer_unreachable);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ assert_true(meshlink_destroy(nut_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 3 -
+ API testing with host node which already joined with a peer node which later
+ goes offline, test host node with an offline peer node case.
+*/
+static void test_case_get_node_reachability_03(void **state) {
+ execute_test(test_get_node_reachability_03, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 3
+
+ Test steps and scenarios:
+ 1. Open Node-Under-Test (NUT) and peer node instance, start peer node instance
+ and invite NUT. NUT joins peer and destroy peer node instance.
+ Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns peer node unreachable status, last_reachable and last_unreachable
+ value as 0 seconds.
+
+ 2. Start the NUT instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns peer node unreachable status, last_reachable and last_unreachable
+ value as 0 seconds.
+
+ 3. Stop the NUT instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns peer node unreachable status, last_reachable and last_unreachable
+ value as 0 seconds.
+
+ 4. Close and reopen NUT instance, Call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns peer node unreachable status, last_reachable and last_unreachable
+ value as 0 seconds.
+
+*/
+static bool test_get_node_reachability_03(void) {
+ bool status;
+ time_t last_unreachable, last_reachable;
+ char nut_confbase[PATH_MAX];
+ char peer_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 3);
+ create_path(peer_confbase, PEER, 3);
+
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open and start peer node instance, invite NUT.
+
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+ assert_true(meshlink_start(mesh_peer));
+ char *invitation = meshlink_invite(mesh_peer, NULL, NUT);
+ assert_non_null(invitation);
+
+ // Open NUT node instance and join with the peer node
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ assert_true(meshlink_join(mesh, invitation));
+ free(invitation);
+ meshlink_node_t *peer_handle = meshlink_get_node(mesh, PEER);
+ assert_non_null(peer_handle);
+
+ // Cleanup peer node instance
+
+ meshlink_close(mesh_peer);
+ assert_true(meshlink_destroy(peer_confbase));
+
+ // Call meshlink_get_node_reachability API with valid arguments
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Start NUT node instance
+
+ assert_true(meshlink_start(mesh));
+
+ // Call meshlink_get_node_reachability API with valid arguments
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Stop NUT node instance
+
+ meshlink_stop(mesh);
+
+ // Call meshlink_get_node_reachability API with valid arguments
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Reinitialize NUT node instance
+
+ meshlink_close(mesh);
+ mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ peer_handle = meshlink_get_node(mesh, PEER);
+ assert_non_null(peer_handle);
+
+ // Call meshlink_get_node_reachability API with valid arguments
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Cleanup NUT
+
+ meshlink_close(mesh);
+ assert_true(meshlink_destroy(nut_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 4 -
+ API testing around invited and invitee node.
+*/
+static void test_case_get_node_reachability_04(void **state) {
+ execute_test(test_get_node_reachability_04, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 4
+
+ Test steps and scenarios:
+ 1. Open Node-Under-Test (NUT) and peer node instance, join both the node and
+ bring them online. Call meshlink_get_node_reachability API from both the nodes.
+ Expected Result:
+ API for both the nodes returns reachable status, last_reachable should be
+ some non-zero positive seconds and last_unreachable should be 0 seconds.
+
+ 2. Stop both the node instances, Call meshlink_get_node_reachability API from both the nodes.
+ Expected Result:
+ API for both the nodes returns unreachable status. last_reachable should match with
+ the old value and last_unreachable should be non-zero positive value.
+
+ 3. Restart both the node instances, Call meshlink_get_node_reachability APIs.
+ Expected Result:
+ API for both the nodes should return reachable status. last_reachable should not match with
+ the old value, but last_unreachable should remain same
+
+ 4. Close and reopen both the node instances, Call meshlink_get_node_reachability APIs.
+ Expected Result:
+ API returns self node unreachable status, last_reachable should remain same
+ but last_unreachable should vary.
+
+ 4. Start both the node instances, Call meshlink_get_node_reachability APIs.
+ Expected Result:
+ API returns self node reachable status, last_reachable should vary and
+ last_unreachable remains same.
+
+*/
+static bool test_get_node_reachability_04(void) {
+ bool status;
+ time_t last_nut_unreachable, last_nut_reachable;
+ time_t last_peer_unreachable, last_peer_reachable;
+ time_t last_reachable, last_unreachable;
+ char nut_confbase[PATH_MAX];
+ char peer_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 4);
+ create_path(peer_confbase, PEER, 4);
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open both NUT and peer node instance, invite and join NUT with peer node.
+
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+ meshlink_set_node_status_cb(mesh_peer, meshlink_node_reachable_status_cb);
+ char *invitation = meshlink_invite(mesh_peer, NULL, NUT);
+ assert_non_null(invitation);
+ assert_true(meshlink_start(mesh_peer));
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ meshlink_set_node_status_cb(mesh, meshlink_node_reachable_status_cb);
+ assert_true(meshlink_join(mesh, invitation));
+ free(invitation);
+
+ meshlink_node_t *peer_handle = meshlink_get_node(mesh, PEER);
+ assert_non_null(peer_handle);
+ meshlink_node_t *nut_handle = meshlink_get_node(mesh_peer, NUT);
+ assert_non_null(nut_handle);
+
+ // Bring nodes online.
+
+ set_sync_flag(&peer_reachable_status_cond, false);
+ set_sync_flag(&nut_reachable_status_cond, false);
+ assert_true(meshlink_start(mesh));
+ assert_true(wait_sync_flag(&peer_reachable_status_cond, 60));
+ assert_true(peer_reachable_status);
+ assert_true(wait_sync_flag(&nut_reachable_status_cond, 60));
+ assert_true(nut_reachable_status);
+
+ // Call meshlink_get_node_reachability API from joined node and also from joining node.
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+ last_peer_reachable = last_reachable;
+
+ status = meshlink_get_node_reachability(mesh_peer, nut_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+ last_nut_reachable = last_reachable;
+
+ // Stop the node instances of both peer and NUT.
+
+ meshlink_stop(mesh);
+ meshlink_stop(mesh_peer);
+
+ // Call meshlink_get_node_reachability API from joined node and also from joining node.
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_not_equal(last_unreachable, 0);
+ assert_int_equal(last_reachable, last_peer_reachable);
+ last_peer_unreachable = last_unreachable;
+
+ status = meshlink_get_node_reachability(mesh_peer, nut_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_not_equal(last_unreachable, 0);
+ assert_int_equal(last_reachable, last_nut_reachable);
+ last_nut_unreachable = last_unreachable;
+
+ // Restart the node instances of both peer and NUT and wait for nodes to come online
+
+ sleep(2);
+ set_sync_flag(&peer_reachable_status_cond, false);
+ set_sync_flag(&nut_reachable_status_cond, false);
+ assert_true(meshlink_start(mesh));
+ assert_true(meshlink_start(mesh_peer));
+
+ assert_true(wait_sync_flag(&peer_reachable_status_cond, 60));
+ assert_true(peer_reachable_status);
+ assert_true(wait_sync_flag(&nut_reachable_status_cond, 60));
+ assert_true(nut_reachable_status);
+
+ // Call meshlink_get_node_reachability API from joined node and also from joining node.
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, last_peer_reachable);
+ assert_int_equal(last_unreachable, last_peer_unreachable);
+ last_peer_reachable = last_reachable;
+
+ status = meshlink_get_node_reachability(mesh_peer, nut_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, last_nut_reachable);
+ assert_int_equal(last_unreachable, last_nut_unreachable);
+ last_nut_reachable = last_reachable;
+
+ // Reinitialize the node instances of both peer and NUT
+
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+
+ sleep(2);
+
+ mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ meshlink_set_node_status_cb(mesh, meshlink_node_reachable_status_cb);
+ mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+ meshlink_set_node_status_cb(mesh_peer, meshlink_node_reachable_status_cb);
+
+ peer_handle = meshlink_get_node(mesh, PEER);
+ assert_non_null(peer_handle);
+ nut_handle = meshlink_get_node(mesh_peer, NUT);
+ assert_non_null(nut_handle);
+
+ // Call meshlink_get_node_reachability API from joined node and also from joining node.
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, last_peer_reachable);
+ assert_int_not_equal(last_unreachable, last_peer_unreachable);
+ last_peer_unreachable = last_unreachable;
+
+ status = meshlink_get_node_reachability(mesh_peer, nut_handle, &last_reachable, &last_unreachable);
+ assert_false(status);
+ assert_int_equal(last_reachable, last_nut_reachable);
+ assert_int_not_equal(last_unreachable, last_nut_unreachable);
+ last_nut_unreachable = last_unreachable;
+
+ // Restart the node instances of both peer and NUT
+
+ set_sync_flag(&peer_reachable_status_cond, false);
+ set_sync_flag(&nut_reachable_status_cond, false);
+
+ assert_true(meshlink_start(mesh));
+ assert_true(meshlink_start(mesh_peer));
+
+ assert_true(wait_sync_flag(&peer_reachable_status_cond, 60));
+ assert_true(peer_reachable_status);
+ assert_true(wait_sync_flag(&nut_reachable_status_cond, 60));
+ assert_true(nut_reachable_status);
+
+ // Call meshlink_get_node_reachability API from joined node and also from joining node.
+
+ status = meshlink_get_node_reachability(mesh, peer_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, last_peer_reachable);
+ assert_int_equal(last_unreachable, last_peer_unreachable);
+
+ status = meshlink_get_node_reachability(mesh_peer, nut_handle, &last_reachable, &last_unreachable);
+ assert_true(status);
+ assert_int_not_equal(last_reachable, last_nut_reachable);
+ assert_int_equal(last_unreachable, last_nut_unreachable);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+ assert_true(meshlink_destroy(nut_confbase));
+ assert_true(meshlink_destroy(peer_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 5 -
+ API testing by calling it in the meshlink callback(s) and also isolation property.
+*/
+static void test_case_get_node_reachability_05(void **state) {
+ execute_test(test_get_node_reachability_05, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 5
+
+ Test steps and scenarios:
+ 1. Open Node-Under-Test (NUT), peer and peer2 node instances. Join both the peer nodes
+ with NUT and bring them online.
+ Expected Result:
+ API called from the node reachable callback of the latest peer node from NUT
+ about other peer node which joined 1st should return reachable status,
+ last_reachable status as some positive non-zero value and last unreachable value as 0.
+
+*/
+static bool test_get_node_reachability_05(void) {
+ char *invitation;
+ bool status;
+ time_t last_reachable, last_unreachable;
+ char nut_confbase[PATH_MAX];
+ char peer_confbase[PATH_MAX];
+ char peer2_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 5);
+ create_path(peer_confbase, PEER, 5);
+ create_path(peer2_confbase, PEER2, 5);
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open NUT, peer and peer2 and join peer nodes with NUT.
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ meshlink_set_node_status_cb(mesh, meshlink_node_reachable_status_cb_2);
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+ meshlink_handle_t *mesh_peer2 = meshlink_open(peer2_confbase, PEER2, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer2);
+
+ assert_true(meshlink_start(mesh));
+
+ invitation = meshlink_invite(mesh, NULL, PEER);
+ assert_non_null(invitation);
+ assert_true(meshlink_join(mesh_peer, invitation));
+ invitation = meshlink_invite(mesh, NULL, PEER2);
+ assert_non_null(invitation);
+ assert_true(meshlink_join(mesh_peer2, invitation));
+
+ // Call meshlink_get_node_reachability API from NUT and check they remained 0 and unreachable
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_node(mesh, PEER), &last_reachable, &last_unreachable);
+ assert_int_equal(status, false);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+ status = meshlink_get_node_reachability(mesh, meshlink_get_node(mesh, PEER2), &last_reachable, &last_unreachable);
+ assert_int_equal(status, false);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Start and wait for the signal from the node reachable callback which is raised when
+ // NUT is able to call meshlink_get_node_reachability API from callback of other peer node.
+
+ set_sync_flag(&peer_reachable_status_cond, false);
+ assert_true(meshlink_start(mesh_peer));
+ assert_true(meshlink_start(mesh_peer2));
+ assert_true(wait_sync_flag(&peer_reachable_status_cond, 60));
+ assert_true(peer_node_callback_test_status);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+ meshlink_close(mesh_peer2);
+ assert_true(meshlink_destroy(nut_confbase));
+ assert_true(meshlink_destroy(peer_confbase));
+ assert_true(meshlink_destroy(peer2_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 6 -
+ Persistence testing on the joining node.
+*/
+static void test_case_get_node_reachability_06(void **state) {
+ execute_test(test_get_node_reachability_06, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 6
+
+ Test steps and scenarios:
+ 1. Open Node-Under-Test (NUT) and invite peer node and close it's instance.
+ Spawn a process which waits for the peer node to join and raises SIGINT if the
+ appropriate callback is received (on the other hand the test suite opens and joins
+ the peer node with NUT in the forked process).
+ Reopen NUT instance in the test suite process and call meshlink_get_node_reachability.
+ Expected Result:
+ API returns peer node unreachable, last_reachable and last_unreachable values
+ as 0 seconds. It is expected that this feature synchronize it at least for the first time
+ when the NUT receives that a new peer node joined.
+
+*/
+static bool test_get_node_reachability_06(void) {
+ bool status;
+ time_t last_reachable, last_unreachable;
+ pid_t pid;
+ int pid_status;
+ char nut_confbase[PATH_MAX];
+ char peer_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 6);
+ create_path(peer_confbase, PEER, 6);
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open NUT node instance and invite peer node. Close NUT node instance.
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ char *invitation = meshlink_invite(mesh, NULL, PEER);
+ meshlink_close(mesh);
+
+ // Set the SIGUSR2 signal handler with handler that signal the condition to the test suite
+
+ sighandler_t usr2sighandler = signal(SIGUSR2, nut_started_user_signal_handler);
+ assert_int_not_equal(usr2sighandler, SIG_ERR);
+
+ // Fork a new process and run NUT in it which just waits for the peer node reachable status callback
+ // and terminates the process immediately.
+
+ pid = fork();
+ assert_int_not_equal(pid, -1);
+
+ if(!pid) {
+ assert(signal(SIGUSR2, SIG_DFL) != SIG_ERR);
+
+ mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert(mesh);
+ meshlink_set_log_cb(mesh, MESHLINK_DEBUG, log_cb);
+ meshlink_set_node_status_cb(mesh, meshlink_node_reachable_status_cb);
+
+ set_sync_flag(&peer_reachable_status_cond, false);
+ assert(meshlink_start(mesh));
+
+ assert(kill(getppid(), SIGUSR2) != -1);
+
+ assert(wait_sync_flag(&peer_reachable_status_cond, 60));
+ assert(peer_reachable_status);
+
+ raise(SIGINT);
+ }
+
+ // Open peer node instance and join with the invitation obtained.
+
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+
+ // Wait for the started signal from NUT and reset the previous SIGUSR2 signal handler
+
+ assert_true(wait_sync_flag(&nut_started_status_cond, 60));
+ assert_int_not_equal(signal(SIGUSR2, usr2sighandler), SIG_ERR);
+
+ assert_true(meshlink_join(mesh_peer, invitation));
+ assert_true(meshlink_start(mesh_peer));
+
+ // Wait for child exit and verify which signal terminated it
+
+ assert_int_not_equal(waitpid(pid, &pid_status, 0), -1);
+ assert_int_equal(WIFSIGNALED(pid_status), true);
+ assert_int_equal(WTERMSIG(pid_status), SIGINT);
+
+ // Reopen the NUT instance in the same test suite
+
+ mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+
+ // Call meshlink_get_node_reachability API and verify that the time stamps has persisted.
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_node(mesh, PEER), &last_reachable, &last_unreachable);
+ assert_int_equal(status, false);
+ assert_int_not_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+ assert_true(meshlink_destroy(nut_confbase));
+ assert_true(meshlink_destroy(peer_confbase));
+ return true;
+}
+
+/*
+ Execute meshlink get last node reachability times feature Test Case # 7 -
+ Persistence testing on the invited node.
+*/
+static void test_case_get_node_reachability_07(void **state) {
+ execute_test(test_get_node_reachability_07, state);
+}
+
+/* Test Steps for meshlink_get_node_reachability Test Case # 7
+
+ Test steps and scenarios:
+ 1. Open peer node instance, invite NUT and start peer node. Spawn a new process in
+ which it opens and joins the NUT with peer node.
+ Reopen NUT instance in the test suite process and call meshlink_get_node_reachability API.
+ Expected Result:
+ API returns peer node unreachable, last_reachable and last_unreachable values
+ as 0 seconds. It is expected that this feature synchronize it at least for the first time
+ when the Node-Under-Test joined with the peer node.
+
+*/
+static bool test_get_node_reachability_07(void) {
+ bool status;
+ time_t last_reachable, last_unreachable;
+ pid_t pid;
+ int pid_status;
+ char nut_confbase[PATH_MAX];
+ char peer_confbase[PATH_MAX];
+ create_path(nut_confbase, NUT, 7);
+ create_path(peer_confbase, PEER, 7);
+ meshlink_set_log_cb(NULL, MESHLINK_DEBUG, log_cb);
+
+ // Open peer node instance and invite NUT.
+
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, GET_NODE_REACHABILITY,
+ DEV_CLASS_STATIONARY);
+ assert_int_not_equal(mesh_peer, NULL);
+ char *invitation = meshlink_invite(mesh_peer, NULL, NUT);
+ assert_non_null(invitation);
+
+ assert_true(meshlink_start(mesh_peer));
+
+ // Fork a new process in which NUT is joins with the peer node and raises SIGINT to terminate.
+
+ pid = fork();
+ assert_int_not_equal(pid, -1);
+
+ if(!pid) {
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert(mesh);
+ meshlink_set_log_cb(mesh, MESHLINK_DEBUG, log_cb);
+
+ assert(meshlink_join(mesh, invitation));
+
+ raise(SIGINT);
+ }
+
+ // Wait for child exit and verify which signal terminated it
+
+ assert_int_not_equal(waitpid(pid, &pid_status, 0), -1);
+ assert_int_equal(WIFSIGNALED(pid_status), true);
+ assert_int_equal(WTERMSIG(pid_status), SIGINT);
+
+ // Reopen the NUT instance in the same test suite
+
+ meshlink_handle_t *mesh = meshlink_open(nut_confbase, NUT, GET_NODE_REACHABILITY, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+
+ // Call meshlink_get_node_reachability API and verify that the time stamps has persisted.
+
+ status = meshlink_get_node_reachability(mesh, meshlink_get_node(mesh, PEER), &last_reachable, &last_unreachable);
+ assert_int_equal(status, false);
+ assert_int_equal(last_reachable, 0);
+ assert_int_equal(last_unreachable, 0);
+
+ // Cleanup
+
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+ assert_true(meshlink_destroy(nut_confbase));
+ assert_true(meshlink_destroy(peer_confbase));
+ return true;
+}
+
+int test_get_node_reachability(void) {
+ /* State structures for get node reachability Test Cases */
+ black_box_state_t test_case_get_node_reachability_01_state = {
+ .test_case_name = "test_case_get_node_reachability_01",
+ };
+ black_box_state_t test_case_get_node_reachability_02_state = {
+ .test_case_name = "test_case_get_node_reachability_02",
+ };
+ black_box_state_t test_case_get_node_reachability_03_state = {
+ .test_case_name = "test_case_get_node_reachability_03",
+ };
+ black_box_state_t test_case_get_node_reachability_04_state = {
+ .test_case_name = "test_case_get_node_reachability_04",
+ };
+ black_box_state_t test_case_get_node_reachability_05_state = {
+ .test_case_name = "test_case_get_node_reachability_05",
+ };
+ black_box_state_t test_case_get_node_reachability_06_state = {
+ .test_case_name = "test_case_get_node_reachability_06",
+ };
+ black_box_state_t test_case_get_node_reachability_07_state = {
+ .test_case_name = "test_case_get_node_reachability_07",
+ };
+
+ const struct CMUnitTest blackbox_status_tests[] = {
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_01, NULL, NULL,
+ (void *)&test_case_get_node_reachability_01_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_02, NULL, NULL,
+ (void *)&test_case_get_node_reachability_02_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_03, NULL, NULL,
+ (void *)&test_case_get_node_reachability_03_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_04, NULL, NULL,
+ (void *)&test_case_get_node_reachability_04_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_05, NULL, NULL,
+ (void *)&test_case_get_node_reachability_05_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_06, NULL, NULL,
+ (void *)&test_case_get_node_reachability_06_state),
+ cmocka_unit_test_prestate_setup_teardown(test_case_get_node_reachability_07, NULL, NULL,
+ (void *)&test_case_get_node_reachability_07_state),
+ };
+ total_tests += sizeof(blackbox_status_tests) / sizeof(blackbox_status_tests[0]);
+
+ return cmocka_run_group_tests(blackbox_status_tests, NULL, NULL);
+}
projects / meshlink / commitdiff