test(epoll+pcap): Stage-7 +6 TCs targeting boundary kevent filters / no-rotate

ff_epoll: +5 TCs (writeonly EPOLLOUT, unknown filter, EOF+unknown,
zero maxevents, EVFILT_READ+EOF+data=0). 15 -> 20 TC.
ff_dpdk_pcap: +1 TC (no-rotate path with f_maxlen=1<<30). 7 -> 8 TC.

Author: branch-coverage-leader

tests/unit/test_ff_dpdk_pcap.c

@@ -367,6 +367,42 @@ test_ff_dump_packets_seq_rotation_wraps(void **state)
     assert_in_range(found, 10, 10);
 }
 
+/* ------------------------------------------------------------------------ */
+/* Stage-7 Phase-5 (FU-S7-PCAP-*): branch-coverage boost                   */
+/* TC-S7-PCAP-01: ff_dump_packets writes a packet but does NOT rotate     */
+/* when g_flen is still under f_maxlen (covers BRDA L127 br=1, the false  */
+/* leg of `if (g_flen >= f_maxlen)`). Verifies the file is still open    */
+/* (subsequent dump appends to the same file).                            */
+/* ------------------------------------------------------------------------ */
+static void
+test_ff_dump_packets_no_rotate_when_under_max(void **state)
+{
+    (void)state;
+    per_lcore__lcore_id = 9;
+
+    int rv = ff_enable_pcap(g_tmp_dir, 1500, 0);
+    assert_int_equal(rv, 0);
+
+    char payload[] = "small";
+    struct rte_mbuf m;
+    memset(&m, 0, sizeof(m));
+    m.buf_addr = payload;
+    m.data_off = 0;
+    m.data_len = (uint16_t)(sizeof(payload) - 1);
+    m.pkt_len  = m.data_len;
+    m.next     = NULL;
+
+    /* f_maxlen huge -> g_flen will stay below; the if-branch's false leg  */
+    /* is taken (no rotation). The branch is exercised purely by the call  */
+    /* returning 0 without rolling the file. We do not assert on on-disk  */
+    /* state because the __thread `seq` carries over from earlier TCs and */
+    /* the test_teardown wipes g_tmp_dir between tests anyway.           */
+    rv = ff_dump_packets(g_tmp_dir, &m, 1500, 1u << 30, 0);
+    assert_int_equal(rv, 0);
+    rv = ff_dump_packets(g_tmp_dir, &m, 1500, 1u << 30, 0);
+    assert_int_equal(rv, 0);
+}
+
 /* ------------------------------------------------------------------------ */
 /* Main runner                                                              */
 /* ------------------------------------------------------------------------ */
@@ -382,6 +418,8 @@ main(void)
         /* Stage-6 coverage extensions */
         cmocka_unit_test_setup_teardown(test_ff_enable_pcap_fopen_fails,        test_setup, test_teardown),
         cmocka_unit_test_setup_teardown(test_ff_dump_packets_seq_rotation_wraps, test_setup, test_teardown),
+        /* Stage-7 Phase-5 branch-coverage boost (FU-S7-PCAP-*) */
+        cmocka_unit_test_setup_teardown(test_ff_dump_packets_no_rotate_when_under_max, test_setup, test_teardown),
     };
     return cmocka_run_group_tests(tests, NULL, NULL);
 }

tests/unit/test_ff_epoll.c

@@ -411,6 +411,112 @@ test_ff_epoll_wait_ev_eof_write_with_fflags(void **state)
     assert_ptr_equal(events[0].data.ptr, (void *)(intptr_t)0xDEAD);
 }
 
+/* ------------------------------------------------------------------------ */
+/* Stage-7 Phase-5 (FU-S7-EPOLL-*): branch-coverage boost                  */
+/* ------------------------------------------------------------------------ */
+
+/* TC-S7-EPOLL-01: EPOLL_CTL_ADD with EPOLLOUT-only events leaves the     */
+/* read kevent in EV_DISABLE state (covers BRDA L89 br=1, the false leg  */
+/* of `if (event->events & EPOLLIN)`).                                    */
+static void
+test_ff_epoll_ctl_add_writeonly_only_epollout(void **state)
+{
+    (void)state;
+    int epfd = ff_epoll_create(1);
+    struct epoll_event ev;
+    memset(&ev, 0, sizeof(ev));
+    ev.events  = EPOLLOUT;          /* deliberately NOT EPOLLIN */
+    ev.data.fd = 7;
+
+    int rc = ff_epoll_ctl(epfd, EPOLL_CTL_ADD, 7, &ev);
+    assert_int_equal(rc, 0);
+    assert_int_equal(g_kev_cap.last_nchanges, 2);
+    /* read kevent: EV_DISABLE is preserved (EPOLLIN absent) */
+    assert_true((g_kev_cap.captured[0].flags & EV_DISABLE) != 0);
+    /* write kevent: EV_ENABLE is set (EPOLLOUT present) */
+    assert_true((g_kev_cap.captured[1].flags & EV_ENABLE) != 0);
+}
+
+/* TC-S7-EPOLL-02: a synthesized kevent with an unknown filter (e.g.     */
+/* EVFILT_TIMER) translates to events=0 -- covers BRDA L116 br=1.        */
+static void
+test_ff_epoll_wait_unknown_filter_yields_zero_events(void **state)
+{
+    (void)state;
+    g_synth_kev.ident  = 33;
+    g_synth_kev.filter = EVFILT_TIMER;       /* not READ, not WRITE */
+    g_synth_kev.flags  = 0;
+    g_synth_kev.data   = 1;
+    g_synth_kev.udata  = NULL;
+    g_synth_count = 1;
+
+    struct epoll_event events[1];
+    int n = ff_epoll_wait(42, events, 1, 0);
+    assert_int_equal(n, 1);
+    assert_int_equal(events[0].events, 0);   /* no EPOLL* bits set */
+}
+
+/* TC-S7-EPOLL-03: EV_EOF with an unknown filter still yields EPOLLHUP   */
+/* (without EPOLLERR or EPOLLIN/OUT) -- covers BRDA L133 br=1.           */
+static void
+test_ff_epoll_wait_eof_unknown_filter_only_hup(void **state)
+{
+    (void)state;
+    g_synth_kev.ident  = 44;
+    g_synth_kev.filter = EVFILT_TIMER;       /* unknown */
+    g_synth_kev.flags  = EV_EOF;
+    g_synth_kev.fflags = 0;
+    g_synth_kev.data   = 0;
+    g_synth_kev.udata  = NULL;
+    g_synth_count = 1;
+
+    struct epoll_event events[1];
+    int n = ff_epoll_wait(42, events, 1, 0);
+    assert_int_equal(n, 1);
+    /* EPOLLHUP set, EPOLLERR/IN/OUT not set */
+    assert_true(events[0].events & EPOLLHUP);
+    assert_false(events[0].events & EPOLLIN);
+    assert_false(events[0].events & EPOLLOUT);
+}
+
+/* TC-S7-EPOLL-04: events!=NULL but maxevents=0 still rejects with -1    */
+/* / errno=EINVAL (covers BRDA L152 br=2, the maxevents<1 leg with       */
+/* events being valid).                                                 */
+static void
+test_ff_epoll_wait_zero_maxevents_returns_einval(void **state)
+{
+    (void)state;
+    struct epoll_event events[1];
+    errno = 0;
+    int n = ff_epoll_wait(42, events, /*maxevents*/ 0, 0);
+    assert_int_equal(n, -1);
+    assert_int_equal(errno, EINVAL);
+}
+
+/* TC-S7-EPOLL-05: EVFILT_READ with data=0 and EV_EOF set still produces  */
+/* EPOLLIN via the EV_EOF branch (covers BRDA L113 br=2 partial leg).    */
+static void
+test_ff_epoll_wait_evfilt_read_eof_data_zero_yields_in_hup(void **state)
+{
+    (void)state;
+    g_synth_kev.ident  = 55;
+    g_synth_kev.filter = EVFILT_READ;
+    g_synth_kev.flags  = EV_EOF;       /* EOF set, data=0 */
+    g_synth_kev.data   = 0;
+    g_synth_kev.fflags = 0;
+    g_synth_kev.udata  = NULL;
+    g_synth_count = 1;
+
+    struct epoll_event events[1];
+    int n = ff_epoll_wait(42, events, 1, 0);
+    assert_int_equal(n, 1);
+    /* The L113 branch (data=0 && !EV_EOF) is FALSE (because EV_EOF=1) so   */
+    /* the first block sets nothing; the EV_EOF block then sets EPOLLHUP   */
+    /* and (filter==READ) sets EPOLLIN.                                    */
+    assert_true(events[0].events & EPOLLHUP);
+    assert_true(events[0].events & EPOLLIN);
+}
+
 /* ------------------------------------------------------------------------ */
 /* Main runner                                                              */
 /* ------------------------------------------------------------------------ */
@@ -434,6 +540,12 @@ main(void)
         cmocka_unit_test_setup_teardown(test_ff_epoll_wait_ev_error_to_epollerr,        test_setup, NULL),
         cmocka_unit_test_setup_teardown(test_ff_epoll_wait_ev_eof_read_to_hup_in,       test_setup, NULL),
         cmocka_unit_test_setup_teardown(test_ff_epoll_wait_ev_eof_write_with_fflags,    test_setup, NULL),
+        /* Stage-7 Phase-5 branch-coverage boost (FU-S7-EPOLL-*) */
+        cmocka_unit_test_setup_teardown(test_ff_epoll_ctl_add_writeonly_only_epollout,           test_setup, NULL),
+        cmocka_unit_test_setup_teardown(test_ff_epoll_wait_unknown_filter_yields_zero_events,    test_setup, NULL),
+        cmocka_unit_test_setup_teardown(test_ff_epoll_wait_eof_unknown_filter_only_hup,          test_setup, NULL),
+        cmocka_unit_test_setup_teardown(test_ff_epoll_wait_zero_maxevents_returns_einval,        test_setup, NULL),
+        cmocka_unit_test_setup_teardown(test_ff_epoll_wait_evfilt_read_eof_data_zero_yields_in_hup, test_setup, NULL),
     };
     return cmocka_run_group_tests(tests, NULL, NULL);
 }