+/* Execute meshlink_channel_set_poll_cb Test Case # 4 - Corner cases */
+static void test_case_channel_set_poll_cb_04(void **state) {
+ execute_test(test_steps_channel_set_poll_cb_04, state);
+}
+/* Test Steps for meshlink_channel_set_poll_cb Test Case # 4
+
+ Test Scenarios:
+ 1. Validate that Node-Under-Test never invokes the poll callback from a silent channel, here 65 seconds
+ 2. Send some data on to the data channel and block the reader end of the channel for a while where
+ at that instance nUT should not invokes any periodic callbacks. Once the peer node unblocks it's
+ instance it should continue to invokes callbacks.
+ This should repeat until the NUT channel sends it's complete data or the poll callback invokes with
+ max default size as length.
+ 3. Send a big packet of maximum send buffer size where length becomes 0 bytes, still NUT channel
+ should not invoke 0 length callback. Make sure by blocking the receiver and assert on the poll callback.
+ 4. NUT channel should not invoke the poll callback after self node going offline or due to it's reachability status.
+ 5. Modify the channel send buffer queue size which should be the new poll callback size further.
+*/
+static bool test_steps_channel_set_poll_cb_04(void) {
+ 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);
+ mesh = meshlink_open(nut_confbase, NUT, TEST_POLL_CB, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh);
+ meshlink_handle_t *mesh_peer = meshlink_open(peer_confbase, PEER, TEST_POLL_CB, DEV_CLASS_STATIONARY);
+ assert_non_null(mesh_peer);
+
+ link_meshlink_pair(mesh, mesh_peer);
+ meshlink_set_channel_accept_cb(mesh_peer, accept_cb);
+
+ assert_true(meshlink_start(mesh));
+ assert_true(meshlink_start(mesh_peer));
+ meshlink_node_t *node = meshlink_get_node(mesh, PEER);
+
+ /* 1. Accept and stay idle for 65 seconds */
+
+ bzero(&poll_cb_data, sizeof(poll_cb_data));
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+
+ meshlink_channel_t *channel = meshlink_channel_open(mesh, node, PORT, NULL, NULL, 0);
+ assert_non_null(channel);
+ meshlink_set_channel_poll_cb(mesh, channel, poll_cb2);
+ sleep(65);
+ assert_int_equal(poll_cb_data.total_cb_count, 1);
+ assert_int_not_equal(poll_cb_data.cb_data_len, 0);
+ size_t default_max_size = poll_cb_data.cb_data_len;
+
+ // Send 7 MSS size packet
+
+ char *buffer = malloc(default_max_size);
+ assert_non_null(buffer);
+ size_t send_size = default_max_size;
+ bzero(&poll_cb_data, sizeof(poll_cb_data));
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+
+ size_t mss_size = meshlink_channel_get_mss(mesh, channel);
+ assert_int_not_equal(mss_size, -1);
+
+ if(mss_size * 7 <= default_max_size) {
+ send_size = mss_size * 7;
+ }
+
+ /* 2. Validate whether poll callback is invoked in case of channel is holding data in send buffer for a while */
+
+ bzero(&poll_cb_data, sizeof(poll_cb_data));
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+ poll_cb_data.cb_handler = poll_cb_data_handler;
+ recv_cb_data.cb_handler = recv_cb_data_handler;
+ assert_int_equal(meshlink_channel_send(mesh, channel, buffer, send_size), send_size);
+ assert_after(poll_cb_data.cb_data_len == default_max_size, 60);
+ assert_int_equal(recv_cb_data.cb_total_data_len, send_size);
+
+ /* 3. On sending max send buffer sized packed on a channel should not invoke callback with length 0 */
+
+ bzero(&poll_cb_data, sizeof(poll_cb_data));
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+ poll_cb_data.cb_handler = poll_cb_data_handler;
+ recv_cb_data.cb_handler = recv_cb_data_handler3;
+ recv_cb_data.cb_flag = true;
+ assert_int_equal(meshlink_channel_send(mesh, channel, buffer, default_max_size), default_max_size);
+ assert_after(poll_cb_data.cb_data_len == default_max_size, 60);
+
+
+ /* 4. Poll callback should not be invoked when the self node is offline and it has data in it's buffer */
+
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+ recv_cb_data.cb_handler = recv_cb_data_handler2;
+ poll_cb_data.cb_handler = poll_cb_data_handler;
+ assert_int_equal(meshlink_channel_send(mesh, channel, buffer, send_size), send_size);
+ assert_after(recv_cb_data.cb_flag, 20);
+ sleep(2);
+ assert_int_equal(meshlink_channel_send(mesh, channel, buffer, 50), 50);
+ sleep(2);
+ recv_cb_data.cb_flag = false;
+ assert_true(meshlink_start(mesh));
+ assert_after(poll_cb_data.cb_data_len == default_max_size, 10);
+
+ /* 5. Changing the sendq size should reflect on the poll callback length */
+
+ bzero(&poll_cb_data, sizeof(poll_cb_data));
+ bzero(&recv_cb_data, sizeof(recv_cb_data));
+
+ size_t new_size = meshlink_channel_get_mss(mesh, channel) * 3;
+ assert_int_not_equal(new_size, -1);
+ meshlink_set_channel_sndbuf(mesh, channel, new_size);
+ assert_after(new_size == poll_cb_data.cb_data_len, 5);
+ send_size = new_size / 2;
+ assert_int_equal(meshlink_channel_send(mesh, channel, buffer, send_size), send_size);
+ assert_after(new_size == poll_cb_data.cb_data_len, 5);
+
+ /* If peer node's channel is closed/freed but the host node is not freed then poll callback with length 0 is expected */
+
+ /*assert_int_not_equal(poll_cb_data.cb_total_data_len, 0);
+
+ meshlink_node_t *channel_peer = node_peer->priv;
+ meshlink_channel_close(mesh_peer, channel_peer);
+ assert_after(!poll_cb_data.cb_data_len, 60);*/
+
+ // Cleanup
+
+ free(buffer);
+ meshlink_close(mesh);
+ meshlink_close(mesh_peer);
+ assert_true(meshlink_destroy(nut_confbase));
+ assert_true(meshlink_destroy(peer_confbase));
+ return true;
+}