From: Matias Elo <matias....@nokia.com>

pktio_test_send_failure() tries to transmit a packet which is larger
than odp_pktout_maxlen. ODP API doesn't guarantee what happens when one
tries to send an oversized packet, so remove the test.

Signed-off-by: Matias Elo <matias....@nokia.com>
---
/** Email created from pull request 507 (matiaselo:dev/remove_send_failure)
 ** https://github.com/Linaro/odp/pull/507
 ** Patch: https://github.com/Linaro/odp/pull/507.patch
 ** Base sha: e1c0e4570a45d05dd9f2e8e052ce71164209d112
 ** Merge commit sha: 5c8a91750b004b678b142cbb809359ec0bbcc284
 **/
 test/validation/api/pktio/pktio.c | 204 --------------------------------------
 1 file changed, 204 deletions(-)

diff --git a/test/validation/api/pktio/pktio.c 
b/test/validation/api/pktio/pktio.c
index f5bb2e26a..e82a96839 100644
--- a/test/validation/api/pktio/pktio.c
+++ b/test/validation/api/pktio/pktio.c
@@ -1723,206 +1723,6 @@ static void pktio_test_start_stop(void)
                odp_event_free(ev);
 }
 
-/*
- * This is a pre-condition check that the pktio_test_send_failure()
- * test case can be run. If the TX interface max frame len is larger that the
- * biggest packet we can allocate then the test won't be able to
- * attempt to send packets larger than the max len, so skip the test.
- */
-static int pktio_check_send_failure(void)
-{
-       odp_pktio_t pktio_tx;
-       uint32_t maxlen;
-       odp_pktio_param_t pktio_param;
-       int iface_idx = 0;
-       const char *iface = iface_name[iface_idx];
-       odp_pool_capability_t pool_capa;
-
-       if (odp_pool_capability(&pool_capa) < 0) {
-               fprintf(stderr, "%s: pool capability failed\n", __func__);
-               return ODP_TEST_INACTIVE;
-       };
-
-       memset(&pktio_param, 0, sizeof(pktio_param));
-
-       pktio_param.in_mode = ODP_PKTIN_MODE_DIRECT;
-
-       pktio_tx = odp_pktio_open(iface, pool[iface_idx], &pktio_param);
-       if (pktio_tx == ODP_PKTIO_INVALID) {
-               fprintf(stderr, "%s: failed to open pktio\n", __func__);
-               return ODP_TEST_INACTIVE;
-       }
-
-       /* read the maxlen from the transmit interface */
-       maxlen = odp_pktout_maxlen(pktio_tx);
-
-       odp_pktio_close(pktio_tx);
-
-       /* Failure test supports only single segment */
-       if (pool_capa.pkt.max_seg_len &&
-           pool_capa.pkt.max_seg_len < maxlen + 32)
-               return ODP_TEST_INACTIVE;
-
-       return ODP_TEST_ACTIVE;
-}
-
-static void pktio_test_send_failure(void)
-{
-       odp_pktio_t pktio_tx, pktio_rx;
-       odp_packet_t pkt_tbl[TX_BATCH_LEN];
-       uint32_t pkt_seq[TX_BATCH_LEN];
-       int ret, i, alloc_pkts;
-       uint32_t maxlen;
-       odp_pool_param_t pool_params;
-       odp_pool_t pkt_pool;
-       int long_pkt_idx = TX_BATCH_LEN / 2;
-       pktio_info_t info_rx;
-       odp_pktout_queue_t pktout;
-       odp_pool_capability_t pool_capa;
-
-       pktio_tx = create_pktio(0, ODP_PKTIN_MODE_DIRECT,
-                               ODP_PKTOUT_MODE_DIRECT);
-       if (pktio_tx == ODP_PKTIO_INVALID) {
-               CU_FAIL("failed to open pktio");
-               return;
-       }
-
-       CU_ASSERT_FATAL(odp_pktout_queue(pktio_tx, &pktout, 1) == 1);
-
-       /* read maxlen from the transmit interface */
-       maxlen = odp_pktout_maxlen(pktio_tx);
-
-       ret = odp_pktio_start(pktio_tx);
-       CU_ASSERT_FATAL(ret == 0);
-
-       _pktio_wait_linkup(pktio_tx);
-
-       CU_ASSERT_FATAL(odp_pool_capability(&pool_capa) == 0);
-
-       if (pool_capa.pkt.max_seg_len &&
-           pool_capa.pkt.max_seg_len < maxlen + 32) {
-               CU_FAIL("Max packet seg length is too small.");
-               return;
-       }
-
-       /* configure the pool so that we can generate test packets larger
-        * than the interface max transmit length */
-       odp_pool_param_init(&pool_params);
-       pool_params.pkt.len     = maxlen + 32;
-       pool_params.pkt.seg_len = pool_params.pkt.len;
-       pool_params.pkt.num     = TX_BATCH_LEN + 1;
-       pool_params.type        = ODP_POOL_PACKET;
-       pkt_pool = odp_pool_create("pkt_pool_oversize", &pool_params);
-       CU_ASSERT_FATAL(pkt_pool != ODP_POOL_INVALID);
-
-       if (num_ifaces > 1) {
-               pktio_rx = create_pktio(1, ODP_PKTIN_MODE_DIRECT,
-                                       ODP_PKTOUT_MODE_DIRECT);
-               ret = odp_pktio_start(pktio_rx);
-               CU_ASSERT_FATAL(ret == 0);
-
-               _pktio_wait_linkup(pktio_rx);
-       } else {
-               pktio_rx = pktio_tx;
-       }
-
-       /* generate a batch of packets with a single overly long packet
-        * in the middle */
-       for (i = 0; i < TX_BATCH_LEN; ++i) {
-               uint32_t pkt_len;
-
-               if (i == long_pkt_idx)
-                       pkt_len = pool_params.pkt.len;
-               else
-                       pkt_len = PKT_LEN_NORMAL;
-
-               pkt_tbl[i] = odp_packet_alloc(pkt_pool, pkt_len);
-               if (pkt_tbl[i] == ODP_PACKET_INVALID)
-                       break;
-
-               pkt_seq[i] = pktio_init_packet(pkt_tbl[i]);
-
-               pktio_pkt_set_macs(pkt_tbl[i], pktio_tx, pktio_rx);
-               if (pktio_fixup_checksums(pkt_tbl[i]) != 0) {
-                       odp_packet_free(pkt_tbl[i]);
-                       break;
-               }
-
-               if (pkt_seq[i] == TEST_SEQ_INVALID) {
-                       odp_packet_free(pkt_tbl[i]);
-                       break;
-               }
-       }
-       alloc_pkts = i;
-
-       if (alloc_pkts == TX_BATCH_LEN) {
-               /* try to send the batch with the long packet in the middle,
-                * the initial short packets should be sent successfully */
-               odp_errno_zero();
-               ret = odp_pktout_send(pktout, pkt_tbl, TX_BATCH_LEN);
-               CU_ASSERT(ret == long_pkt_idx);
-               if (ret != long_pkt_idx)
-                       goto cleanup;
-               CU_ASSERT(odp_errno() == 0);
-
-               info_rx.id   = pktio_rx;
-               info_rx.inq  = ODP_QUEUE_INVALID;
-               info_rx.in_mode = ODP_PKTIN_MODE_DIRECT;
-
-               i = wait_for_packets(&info_rx, pkt_tbl, pkt_seq, ret,
-                                    TXRX_MODE_MULTI, ODP_TIME_SEC_IN_NS);
-
-               if (i == ret) {
-                       /* now try to send starting with the too-long packet
-                        * and verify it fails */
-                       odp_errno_zero();
-                       ret = odp_pktout_send(pktout,
-                                             &pkt_tbl[long_pkt_idx],
-                                             TX_BATCH_LEN - long_pkt_idx);
-                       CU_ASSERT(ret == -1);
-                       CU_ASSERT(odp_errno() != 0);
-               } else {
-                       CU_FAIL("failed to receive transmitted packets\n");
-               }
-
-               /* now reduce the size of the long packet and attempt to send
-                * again - should work this time */
-               i = long_pkt_idx;
-               odp_packet_pull_tail(pkt_tbl[i],
-                                    odp_packet_len(pkt_tbl[i]) -
-                                    PKT_LEN_NORMAL);
-               pkt_seq[i] = pktio_init_packet(pkt_tbl[i]);
-
-               pktio_pkt_set_macs(pkt_tbl[i], pktio_tx, pktio_rx);
-               ret = pktio_fixup_checksums(pkt_tbl[i]);
-               CU_ASSERT_FATAL(ret == 0);
-
-               CU_ASSERT_FATAL(pkt_seq[i] != TEST_SEQ_INVALID);
-               ret = odp_pktout_send(pktout, &pkt_tbl[i], TX_BATCH_LEN - i);
-               CU_ASSERT_FATAL(ret == (TX_BATCH_LEN - i));
-
-               i = wait_for_packets(&info_rx, &pkt_tbl[i], &pkt_seq[i], ret,
-                                    TXRX_MODE_MULTI, ODP_TIME_SEC_IN_NS);
-               CU_ASSERT(i == ret);
-       } else {
-               CU_FAIL("failed to generate test packets\n");
-       }
-
-       for (i = 0; i < alloc_pkts; ++i) {
-               if (pkt_tbl[i] != ODP_PACKET_INVALID)
-                       odp_packet_free(pkt_tbl[i]);
-       }
-
-cleanup:
-       if (pktio_rx != pktio_tx) {
-               CU_ASSERT(odp_pktio_stop(pktio_rx) == 0);
-               CU_ASSERT(odp_pktio_close(pktio_rx) == 0);
-       }
-       CU_ASSERT(odp_pktio_stop(pktio_tx) == 0);
-       CU_ASSERT(odp_pktio_close(pktio_tx) == 0);
-       CU_ASSERT(odp_pool_destroy(pkt_pool) == 0);
-}
-
 static void pktio_test_recv_on_wonly(void)
 {
        odp_pktio_t pktio;
@@ -2221,8 +2021,6 @@ odp_testinfo_t pktio_suite_unsegmented[] = {
        ODP_TEST_INFO(pktio_test_recv_tmo),
        ODP_TEST_INFO(pktio_test_recv_mq_tmo),
        ODP_TEST_INFO(pktio_test_recv_mtu),
-       ODP_TEST_INFO_CONDITIONAL(pktio_test_send_failure,
-                                 pktio_check_send_failure),
        ODP_TEST_INFO(pktio_test_mtu),
        ODP_TEST_INFO(pktio_test_promisc),
        ODP_TEST_INFO(pktio_test_mac),
@@ -2247,8 +2045,6 @@ odp_testinfo_t pktio_suite_segmented[] = {
        ODP_TEST_INFO(pktio_test_recv),
        ODP_TEST_INFO(pktio_test_recv_multi),
        ODP_TEST_INFO(pktio_test_recv_mtu),
-       ODP_TEST_INFO_CONDITIONAL(pktio_test_send_failure,
-                                 pktio_check_send_failure),
        ODP_TEST_INFO_NULL
 };
 

Reply via email to