[4/5] validation: cls: use correct MAC addresses

If pktion is in not promisc mode, a packet should contain correct
MAC address.

Signed-off-by: Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
---
 .../classification/odp_classification_test_pmr.c   | 158 ++++++++++-----------
 .../classification/odp_classification_tests.c      |  30 +++-
 2 files changed, 96 insertions(+), 92 deletions(-)

The idea of having to create pktio in each and every test case is to
create robustness in test cases and have them as independent from each
other as possible. In classification when you remove a CoS rule it is
not expected to see the changes immediately some systems will have
latency and the packets might be classified using stale rules.
So it is better to destroy and re-create pktio interface for each test cases.

Regards,
Bala
Regards,
Bala


On 12 January 2016 at 23:41, Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org> wrote:
> If pktion is in not promisc mode, a packet should contain correct
> MAC address.
>
> Signed-off-by: Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
> ---
>  .../classification/odp_classification_test_pmr.c   | 158 ++++++++++-----------
>  .../classification/odp_classification_tests.c      |  30 +++-
>  2 files changed, 96 insertions(+), 92 deletions(-)
>
> diff --git a/test/validation/classification/odp_classification_test_pmr.c b/test/validation/classification/odp_classification_test_pmr.c
> index 0b3f279..bb69794 100644
> --- a/test/validation/classification/odp_classification_test_pmr.c
> +++ b/test/validation/classification/odp_classification_test_pmr.c
> @@ -13,22 +13,11 @@
>  #include <odp/helper/tcp.h>
>
>  static odp_pool_t pkt_pool;
> +static odp_pktio_t pktio_loop;
>
>  /** sequence number of IP packets */
>  odp_atomic_u32_t seq;
>
> -int classification_suite_pmr_init(void)
> -{
> -       pkt_pool = pool_create("classification_pmr_pool");
> -       if (ODP_POOL_INVALID == pkt_pool) {
> -               fprintf(stderr, "Packet pool creation failed.\n");
> -               return -1;
> -       }
> -
> -       odp_atomic_init_u32(&seq, 0);
> -       return 0;
> -}
> -
>  odp_pktio_t create_pktio(odp_queue_type_t q_type)
>  {
>         odp_pktio_t pktio;
> @@ -55,6 +44,35 @@ odp_pktio_t create_pktio(odp_queue_type_t q_type)
>         return pktio;
>  }
>
> +int classification_suite_pmr_init(void)
> +{
> +       pkt_pool = pool_create("classification_pmr_pool");
> +       if (ODP_POOL_INVALID == pkt_pool) {
> +               fprintf(stderr, "Packet pool creation failed.\n");
> +               return -1;
> +       }
> +
> +       pktio_loop = create_pktio(ODP_QUEUE_TYPE_SCHED);
> +
> +       odp_atomic_init_u32(&seq, 0);
> +       return 0;
> +}
> +
> +static odp_packet_t
> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
> +{
> +       odp_packet_t pkt;
> +       odph_ethhdr_t *eth;
> +
> +       pkt = create_packet(pkt_pool, vlan, seq, flag_udp);
> +
> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
> +
> +       return pkt;
> +}
> +
>  void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
>                            odp_queue_t *queue, odp_pool_t *pool)
>  {
> @@ -93,6 +111,11 @@ int classification_suite_pmr_term(void)
>  {
>         int retcode = 0;
>
> +       if (odp_pktio_close(pktio_loop)) {
> +               fprintf(stderr, "unable to close pktio_loop.\n");
> +               retcode = -1;
> +       }
> +
>         if (0 != odp_pool_destroy(pkt_pool)) {
>                 fprintf(stderr, "pkt_pool destroy failed.\n");
>                 retcode = -1;
> @@ -109,7 +132,6 @@ void classification_test_pmr_term_tcp_dport(void)
>         uint16_t val;
>         uint16_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -128,10 +150,7 @@ void classification_test_pmr_term_tcp_dport(void)
>         mask = 0xffff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_TCP_DPORT;
> @@ -158,10 +177,10 @@ void classification_test_pmr_term_tcp_dport(void)
>         cos = odp_cls_cos_create(cosname, &cls_param);
>         CU_ASSERT(cos != ODP_COS_INVALID);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, false);
> +       pkt = cls_create_packet(false, &seq, false);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -169,7 +188,7 @@ void classification_test_pmr_term_tcp_dport(void)
>         tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -181,7 +200,7 @@ void classification_test_pmr_term_tcp_dport(void)
>         odp_packet_free(pkt);
>
>         /* Other packets are delivered to default queue */
> -       pkt = create_packet(pkt_pool, false, &seq, false);
> +       pkt = cls_create_packet(false, &seq, false);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -189,7 +208,7 @@ void classification_test_pmr_term_tcp_dport(void)
>         tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -206,7 +225,6 @@ void classification_test_pmr_term_tcp_dport(void)
>         odp_queue_destroy(default_queue);
>         odp_pool_destroy(pool);
>         odp_pool_destroy(default_pool);
> -       odp_pktio_close(pktio);
>  }
>
>  void classification_test_pmr_term_tcp_sport(void)
> @@ -217,7 +235,6 @@ void classification_test_pmr_term_tcp_sport(void)
>         uint16_t val;
>         uint16_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -235,10 +252,7 @@ void classification_test_pmr_term_tcp_sport(void)
>         mask = 0xffff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_TCP_SPORT;
> @@ -264,10 +278,10 @@ void classification_test_pmr_term_tcp_sport(void)
>         cos = odp_cls_cos_create(cosname, &cls_param);
>         CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, false);
> +       pkt = cls_create_packet(false, &seq, false);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -275,7 +289,7 @@ void classification_test_pmr_term_tcp_sport(void)
>         tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -285,7 +299,7 @@ void classification_test_pmr_term_tcp_sport(void)
>         CU_ASSERT(recvpool == pool);
>         odp_packet_free(pkt);
>
> -       pkt = create_packet(pkt_pool, false, &seq, false);
> +       pkt = cls_create_packet(false, &seq, false);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -293,7 +307,7 @@ void classification_test_pmr_term_tcp_sport(void)
>         tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -310,7 +324,6 @@ void classification_test_pmr_term_tcp_sport(void)
>         odp_pool_destroy(pool);
>         odp_queue_destroy(queue);
>         odp_queue_destroy(default_queue);
> -       odp_pktio_close(pktio);
>  }
>
>  void classification_test_pmr_term_udp_dport(void)
> @@ -321,7 +334,6 @@ void classification_test_pmr_term_udp_dport(void)
>         uint16_t val;
>         uint16_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_pool_t pool;
>         odp_pool_t recvpool;
>         odp_queue_t queue;
> @@ -339,10 +351,7 @@ void classification_test_pmr_term_udp_dport(void)
>         mask = 0xffff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_UDP_DPORT;
> @@ -368,10 +377,10 @@ void classification_test_pmr_term_udp_dport(void)
>         cos = odp_cls_cos_create(cosname, &cls_param);
>         CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -379,7 +388,7 @@ void classification_test_pmr_term_udp_dport(void)
>         udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -390,7 +399,7 @@ void classification_test_pmr_term_udp_dport(void)
>         odp_packet_free(pkt);
>
>         /* Other packets received in default queue */
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -398,7 +407,7 @@ void classification_test_pmr_term_udp_dport(void)
>         udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -415,7 +424,6 @@ void classification_test_pmr_term_udp_dport(void)
>         odp_queue_destroy(default_queue);
>         odp_pool_destroy(default_pool);
>         odp_pool_destroy(pool);
> -       odp_pktio_close(pktio);
>  }
>
>  void classification_test_pmr_term_udp_sport(void)
> @@ -426,7 +434,6 @@ void classification_test_pmr_term_udp_sport(void)
>         uint16_t val;
>         uint16_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -444,10 +451,7 @@ void classification_test_pmr_term_udp_sport(void)
>         mask = 0xffff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_UDP_SPORT;
> @@ -473,10 +477,10 @@ void classification_test_pmr_term_udp_sport(void)
>         cos = odp_cls_cos_create(cosname, &cls_param);
>         CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -484,7 +488,7 @@ void classification_test_pmr_term_udp_sport(void)
>         udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -494,7 +498,7 @@ void classification_test_pmr_term_udp_sport(void)
>         CU_ASSERT(recvpool == pool);
>         odp_packet_free(pkt);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -502,7 +506,7 @@ void classification_test_pmr_term_udp_sport(void)
>         udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>         udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -519,7 +523,6 @@ void classification_test_pmr_term_udp_sport(void)
>         odp_pool_destroy(pool);
>         odp_queue_destroy(queue);
>         odp_queue_destroy(default_queue);
> -       odp_pktio_close(pktio);
>  }
>
>  void classification_test_pmr_term_ipproto(void)
> @@ -529,7 +532,6 @@ void classification_test_pmr_term_ipproto(void)
>         uint8_t val;
>         uint8_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -547,10 +549,7 @@ void classification_test_pmr_term_ipproto(void)
>         mask = 0xff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_IPPROTO;
> @@ -576,15 +575,15 @@ void classification_test_pmr_term_ipproto(void)
>         cos = odp_cls_cos_create(cosname, &cls_param);
>         CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -595,12 +594,12 @@ void classification_test_pmr_term_ipproto(void)
>         odp_packet_free(pkt);
>
>         /* Other packets delivered to default queue */
> -       pkt = create_packet(pkt_pool, false, &seq, false);
> +       pkt = cls_create_packet(false, &seq, false);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -617,7 +616,6 @@ void classification_test_pmr_term_ipproto(void)
>         odp_pool_destroy(pool);
>         odp_queue_destroy(queue);
>         odp_queue_destroy(default_queue);
> -       odp_pktio_close(pktio);
>  }
>
>  static void classification_test_pmr_pool_set(void)
> @@ -627,7 +625,6 @@ static void classification_test_pmr_pool_set(void)
>         uint8_t val;
>         uint8_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -646,10 +643,7 @@ static void classification_test_pmr_pool_set(void)
>         mask = 0xff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_IPPROTO;
> @@ -682,15 +676,15 @@ static void classification_test_pmr_pool_set(void)
>         retval = odp_cls_cos_pool_set(cos, pool_new);
>         CU_ASSERT(retval == 0);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -709,7 +703,6 @@ static void classification_test_pmr_pool_set(void)
>         odp_pool_destroy(pool_new);
>         odp_queue_destroy(queue);
>         odp_queue_destroy(default_queue);
> -       odp_pktio_close(pktio);
>  }
>
>  static void classification_test_pmr_queue_set(void)
> @@ -719,7 +712,6 @@ static void classification_test_pmr_queue_set(void)
>         uint8_t val;
>         uint8_t mask;
>         int retval;
> -       odp_pktio_t pktio;
>         odp_queue_t queue;
>         odp_queue_t retqueue;
>         odp_queue_t default_queue;
> @@ -738,10 +730,7 @@ static void classification_test_pmr_queue_set(void)
>         mask = 0xff;
>         seqno = 0;
>
> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
> -
> -       configure_default_cos(pktio, &default_cos,
> +       configure_default_cos(pktio_loop, &default_cos,
>                               &default_queue, &default_pool);
>
>         match.term = ODP_PMR_IPPROTO;
> @@ -774,15 +763,15 @@ static void classification_test_pmr_queue_set(void)
>         retval = odp_cos_queue_set(cos, queue_new);
>         CU_ASSERT(retval == 0);
>
> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>         CU_ASSERT(retval == 0);
>
> -       pkt = create_packet(pkt_pool, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
>
> -       enqueue_pktio_interface(pkt, pktio);
> +       enqueue_pktio_interface(pkt, pktio_loop);
>
>         pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
> @@ -801,7 +790,6 @@ static void classification_test_pmr_queue_set(void)
>         odp_queue_destroy(queue_new);
>         odp_queue_destroy(queue);
>         odp_queue_destroy(default_queue);
> -       odp_pktio_close(pktio);
>  }
>
>  odp_testinfo_t classification_suite_pmr[] = {
> diff --git a/test/validation/classification/odp_classification_tests.c b/test/validation/classification/odp_classification_tests.c
> index a118728..34fc570 100644
> --- a/test/validation/classification/odp_classification_tests.c
> +++ b/test/validation/classification/odp_classification_tests.c
> @@ -118,6 +118,21 @@ int classification_suite_term(void)
>         return retcode;
>  }
>
> +static odp_packet_t
> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
> +{
> +       odp_packet_t pkt;
> +       odph_ethhdr_t *eth;
> +
> +       pkt = create_packet(pool_default, vlan, seq, flag_udp);
> +
> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
> +
> +       return pkt;
> +}
> +
>  void configure_cls_pmr_chain(void)
>  {
>         /* PKTIO --> PMR_SRC(SRC IP ADDR) --> PMR_DST (TCP SPORT) */
> @@ -225,7 +240,7 @@ void test_cls_pmr_chain(void)
>         uint32_t mask;
>         uint32_t seqno = 0;
>
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -248,7 +263,7 @@ void test_cls_pmr_chain(void)
>         CU_ASSERT(pool == pool_list[CLS_PMR_CHAIN_DST]);
>         odp_packet_free(pkt);
>
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -309,8 +324,9 @@ void test_pktio_default_cos(void)
>         odp_queue_t queue;
>         uint32_t seqno = 0;
>         odp_pool_t pool;
> +
>         /* create a default packet */
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -371,7 +387,7 @@ void test_pktio_error_cos(void)
>         odp_pool_t pool;
>
>         /*Create an error packet */
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         odph_ipv4hdr_t *ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL);
>
> @@ -482,7 +498,7 @@ void test_cos_with_l2_priority(void)
>
>         uint8_t i;
>         for (i = 0; i < CLS_L2_QOS_MAX; i++) {
> -               pkt = create_packet(pool_default, true, &seq, true);
> +               pkt = cls_create_packet(true, &seq, true);
>                 CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>                 seqno = cls_pkt_get_seq(pkt);
>                 CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -557,7 +573,7 @@ void test_pmr_cos(void)
>         odp_pool_t pool;
>         uint32_t seqno = 0;
>
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> @@ -642,7 +658,7 @@ void test_pktio_pmr_match_set_cos(void)
>         odp_queue_t queue;
>         uint32_t seqno = 0;
>
> -       pkt = create_packet(pool_default, false, &seq, true);
> +       pkt = cls_create_packet(false, &seq, true);
>         CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>         seqno = cls_pkt_get_seq(pkt);
>         CU_ASSERT(seqno != TEST_SEQ_INVALID);
> --
> 1.9.1
>

On 14.01.16 07:59, Bala Manoharan wrote:
> The idea of having to create pktio in each and every test case is to
> create robustness in test cases and have them as independent from each
> other as possible. In classification when you remove a CoS rule it is
> not expected to see the changes immediately some systems will have
> latency and the packets might be classified using stale rules.
> So it is better to destroy and re-create pktio interface for each test cases.
>
> Regards,
> Bala
> Regards,
> Bala
>
Agree. Initially I've done like proposed, but then look in odp_classification_tests.c,
and see that mostly common pktio_loop is used. I will correct to set MAC addresses
for each test, but odp_classification_tests.c should be sophisticated also, later.

>
> On 12 January 2016 at 23:41, Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org> wrote:
>> If pktion is in not promisc mode, a packet should contain correct
>> MAC address.
>>
>> Signed-off-by: Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
>> ---
>>   .../classification/odp_classification_test_pmr.c   | 158 ++++++++++-----------
>>   .../classification/odp_classification_tests.c      |  30 +++-
>>   2 files changed, 96 insertions(+), 92 deletions(-)
>>
>> diff --git a/test/validation/classification/odp_classification_test_pmr.c b/test/validation/classification/odp_classification_test_pmr.c
>> index 0b3f279..bb69794 100644
>> --- a/test/validation/classification/odp_classification_test_pmr.c
>> +++ b/test/validation/classification/odp_classification_test_pmr.c
>> @@ -13,22 +13,11 @@
>>   #include <odp/helper/tcp.h>
>>
>>   static odp_pool_t pkt_pool;
>> +static odp_pktio_t pktio_loop;
>>
>>   /** sequence number of IP packets */
>>   odp_atomic_u32_t seq;
>>
>> -int classification_suite_pmr_init(void)
>> -{
>> -       pkt_pool = pool_create("classification_pmr_pool");
>> -       if (ODP_POOL_INVALID == pkt_pool) {
>> -               fprintf(stderr, "Packet pool creation failed.\n");
>> -               return -1;
>> -       }
>> -
>> -       odp_atomic_init_u32(&seq, 0);
>> -       return 0;
>> -}
>> -
>>   odp_pktio_t create_pktio(odp_queue_type_t q_type)
>>   {
>>          odp_pktio_t pktio;
>> @@ -55,6 +44,35 @@ odp_pktio_t create_pktio(odp_queue_type_t q_type)
>>          return pktio;
>>   }
>>
>> +int classification_suite_pmr_init(void)
>> +{
>> +       pkt_pool = pool_create("classification_pmr_pool");
>> +       if (ODP_POOL_INVALID == pkt_pool) {
>> +               fprintf(stderr, "Packet pool creation failed.\n");
>> +               return -1;
>> +       }
>> +
>> +       pktio_loop = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> +
>> +       odp_atomic_init_u32(&seq, 0);
>> +       return 0;
>> +}
>> +
>> +static odp_packet_t
>> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
>> +{
>> +       odp_packet_t pkt;
>> +       odph_ethhdr_t *eth;
>> +
>> +       pkt = create_packet(pkt_pool, vlan, seq, flag_udp);
>> +
>> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
>> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
>> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
>> +
>> +       return pkt;
>> +}
>> +
>>   void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
>>                             odp_queue_t *queue, odp_pool_t *pool)
>>   {
>> @@ -93,6 +111,11 @@ int classification_suite_pmr_term(void)
>>   {
>>          int retcode = 0;
>>
>> +       if (odp_pktio_close(pktio_loop)) {
>> +               fprintf(stderr, "unable to close pktio_loop.\n");
>> +               retcode = -1;
>> +       }
>> +
>>          if (0 != odp_pool_destroy(pkt_pool)) {
>>                  fprintf(stderr, "pkt_pool destroy failed.\n");
>>                  retcode = -1;
>> @@ -109,7 +132,6 @@ void classification_test_pmr_term_tcp_dport(void)
>>          uint16_t val;
>>          uint16_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -128,10 +150,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>          mask = 0xffff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_TCP_DPORT;
>> @@ -158,10 +177,10 @@ void classification_test_pmr_term_tcp_dport(void)
>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>          CU_ASSERT(cos != ODP_COS_INVALID);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>> +       pkt = cls_create_packet(false, &seq, false);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -169,7 +188,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -181,7 +200,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>          odp_packet_free(pkt);
>>
>>          /* Other packets are delivered to default queue */
>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>> +       pkt = cls_create_packet(false, &seq, false);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -189,7 +208,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -206,7 +225,6 @@ void classification_test_pmr_term_tcp_dport(void)
>>          odp_queue_destroy(default_queue);
>>          odp_pool_destroy(pool);
>>          odp_pool_destroy(default_pool);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   void classification_test_pmr_term_tcp_sport(void)
>> @@ -217,7 +235,6 @@ void classification_test_pmr_term_tcp_sport(void)
>>          uint16_t val;
>>          uint16_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -235,10 +252,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>          mask = 0xffff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_TCP_SPORT;
>> @@ -264,10 +278,10 @@ void classification_test_pmr_term_tcp_sport(void)
>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>> +       pkt = cls_create_packet(false, &seq, false);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -275,7 +289,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -285,7 +299,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>          CU_ASSERT(recvpool == pool);
>>          odp_packet_free(pkt);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>> +       pkt = cls_create_packet(false, &seq, false);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -293,7 +307,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -310,7 +324,6 @@ void classification_test_pmr_term_tcp_sport(void)
>>          odp_pool_destroy(pool);
>>          odp_queue_destroy(queue);
>>          odp_queue_destroy(default_queue);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   void classification_test_pmr_term_udp_dport(void)
>> @@ -321,7 +334,6 @@ void classification_test_pmr_term_udp_dport(void)
>>          uint16_t val;
>>          uint16_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_pool_t pool;
>>          odp_pool_t recvpool;
>>          odp_queue_t queue;
>> @@ -339,10 +351,7 @@ void classification_test_pmr_term_udp_dport(void)
>>          mask = 0xffff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_UDP_DPORT;
>> @@ -368,10 +377,10 @@ void classification_test_pmr_term_udp_dport(void)
>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -379,7 +388,7 @@ void classification_test_pmr_term_udp_dport(void)
>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -390,7 +399,7 @@ void classification_test_pmr_term_udp_dport(void)
>>          odp_packet_free(pkt);
>>
>>          /* Other packets received in default queue */
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -398,7 +407,7 @@ void classification_test_pmr_term_udp_dport(void)
>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -415,7 +424,6 @@ void classification_test_pmr_term_udp_dport(void)
>>          odp_queue_destroy(default_queue);
>>          odp_pool_destroy(default_pool);
>>          odp_pool_destroy(pool);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   void classification_test_pmr_term_udp_sport(void)
>> @@ -426,7 +434,6 @@ void classification_test_pmr_term_udp_sport(void)
>>          uint16_t val;
>>          uint16_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -444,10 +451,7 @@ void classification_test_pmr_term_udp_sport(void)
>>          mask = 0xffff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_UDP_SPORT;
>> @@ -473,10 +477,10 @@ void classification_test_pmr_term_udp_sport(void)
>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -484,7 +488,7 @@ void classification_test_pmr_term_udp_sport(void)
>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -494,7 +498,7 @@ void classification_test_pmr_term_udp_sport(void)
>>          CU_ASSERT(recvpool == pool);
>>          odp_packet_free(pkt);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -502,7 +506,7 @@ void classification_test_pmr_term_udp_sport(void)
>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>          udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -519,7 +523,6 @@ void classification_test_pmr_term_udp_sport(void)
>>          odp_pool_destroy(pool);
>>          odp_queue_destroy(queue);
>>          odp_queue_destroy(default_queue);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   void classification_test_pmr_term_ipproto(void)
>> @@ -529,7 +532,6 @@ void classification_test_pmr_term_ipproto(void)
>>          uint8_t val;
>>          uint8_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -547,10 +549,7 @@ void classification_test_pmr_term_ipproto(void)
>>          mask = 0xff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_IPPROTO;
>> @@ -576,15 +575,15 @@ void classification_test_pmr_term_ipproto(void)
>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -595,12 +594,12 @@ void classification_test_pmr_term_ipproto(void)
>>          odp_packet_free(pkt);
>>
>>          /* Other packets delivered to default queue */
>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>> +       pkt = cls_create_packet(false, &seq, false);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -617,7 +616,6 @@ void classification_test_pmr_term_ipproto(void)
>>          odp_pool_destroy(pool);
>>          odp_queue_destroy(queue);
>>          odp_queue_destroy(default_queue);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   static void classification_test_pmr_pool_set(void)
>> @@ -627,7 +625,6 @@ static void classification_test_pmr_pool_set(void)
>>          uint8_t val;
>>          uint8_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -646,10 +643,7 @@ static void classification_test_pmr_pool_set(void)
>>          mask = 0xff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_IPPROTO;
>> @@ -682,15 +676,15 @@ static void classification_test_pmr_pool_set(void)
>>          retval = odp_cls_cos_pool_set(cos, pool_new);
>>          CU_ASSERT(retval == 0);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -709,7 +703,6 @@ static void classification_test_pmr_pool_set(void)
>>          odp_pool_destroy(pool_new);
>>          odp_queue_destroy(queue);
>>          odp_queue_destroy(default_queue);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   static void classification_test_pmr_queue_set(void)
>> @@ -719,7 +712,6 @@ static void classification_test_pmr_queue_set(void)
>>          uint8_t val;
>>          uint8_t mask;
>>          int retval;
>> -       odp_pktio_t pktio;
>>          odp_queue_t queue;
>>          odp_queue_t retqueue;
>>          odp_queue_t default_queue;
>> @@ -738,10 +730,7 @@ static void classification_test_pmr_queue_set(void)
>>          mask = 0xff;
>>          seqno = 0;
>>
>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>> -
>> -       configure_default_cos(pktio, &default_cos,
>> +       configure_default_cos(pktio_loop, &default_cos,
>>                                &default_queue, &default_pool);
>>
>>          match.term = ODP_PMR_IPPROTO;
>> @@ -774,15 +763,15 @@ static void classification_test_pmr_queue_set(void)
>>          retval = odp_cos_queue_set(cos, queue_new);
>>          CU_ASSERT(retval == 0);
>>
>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>          CU_ASSERT(retval == 0);
>>
>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>
>> -       enqueue_pktio_interface(pkt, pktio);
>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>
>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>> @@ -801,7 +790,6 @@ static void classification_test_pmr_queue_set(void)
>>          odp_queue_destroy(queue_new);
>>          odp_queue_destroy(queue);
>>          odp_queue_destroy(default_queue);
>> -       odp_pktio_close(pktio);
>>   }
>>
>>   odp_testinfo_t classification_suite_pmr[] = {
>> diff --git a/test/validation/classification/odp_classification_tests.c b/test/validation/classification/odp_classification_tests.c
>> index a118728..34fc570 100644
>> --- a/test/validation/classification/odp_classification_tests.c
>> +++ b/test/validation/classification/odp_classification_tests.c
>> @@ -118,6 +118,21 @@ int classification_suite_term(void)
>>          return retcode;
>>   }
>>
>> +static odp_packet_t
>> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
>> +{
>> +       odp_packet_t pkt;
>> +       odph_ethhdr_t *eth;
>> +
>> +       pkt = create_packet(pool_default, vlan, seq, flag_udp);
>> +
>> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
>> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
>> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
>> +
>> +       return pkt;
>> +}
>> +
>>   void configure_cls_pmr_chain(void)
>>   {
>>          /* PKTIO --> PMR_SRC(SRC IP ADDR) --> PMR_DST (TCP SPORT) */
>> @@ -225,7 +240,7 @@ void test_cls_pmr_chain(void)
>>          uint32_t mask;
>>          uint32_t seqno = 0;
>>
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -248,7 +263,7 @@ void test_cls_pmr_chain(void)
>>          CU_ASSERT(pool == pool_list[CLS_PMR_CHAIN_DST]);
>>          odp_packet_free(pkt);
>>
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -309,8 +324,9 @@ void test_pktio_default_cos(void)
>>          odp_queue_t queue;
>>          uint32_t seqno = 0;
>>          odp_pool_t pool;
>> +
>>          /* create a default packet */
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -371,7 +387,7 @@ void test_pktio_error_cos(void)
>>          odp_pool_t pool;
>>
>>          /*Create an error packet */
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          odph_ipv4hdr_t *ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt, NULL);
>>
>> @@ -482,7 +498,7 @@ void test_cos_with_l2_priority(void)
>>
>>          uint8_t i;
>>          for (i = 0; i < CLS_L2_QOS_MAX; i++) {
>> -               pkt = create_packet(pool_default, true, &seq, true);
>> +               pkt = cls_create_packet(true, &seq, true);
>>                  CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>                  seqno = cls_pkt_get_seq(pkt);
>>                  CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -557,7 +573,7 @@ void test_pmr_cos(void)
>>          odp_pool_t pool;
>>          uint32_t seqno = 0;
>>
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> @@ -642,7 +658,7 @@ void test_pktio_pmr_match_set_cos(void)
>>          odp_queue_t queue;
>>          uint32_t seqno = 0;
>>
>> -       pkt = create_packet(pool_default, false, &seq, true);
>> +       pkt = cls_create_packet(false, &seq, true);
>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>          seqno = cls_pkt_get_seq(pkt);
>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>> --
>> 1.9.1
>>

In odp_classification_tests.c a common pktio_loop is used coz in that
suite the objective was to test the behaviour of a classification
system with all different possible configurations existing
concurrently. ie Configure L2 PMR, L3 PMR, default_cos, error_cos and
send an error packet and check that the packet reaches error CoS.

Yes tests can be sophisticated but as I pointed out earlier there are
few changes on the way for the classification API and it seems
reasonable to enhance the validation suite once the API changes are
completed.
Regards,
Bala


On 14 January 2016 at 13:09, Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org> wrote:
>
>
> On 14.01.16 07:59, Bala Manoharan wrote:
>>
>> The idea of having to create pktio in each and every test case is to
>> create robustness in test cases and have them as independent from each
>> other as possible. In classification when you remove a CoS rule it is
>> not expected to see the changes immediately some systems will have
>> latency and the packets might be classified using stale rules.
>> So it is better to destroy and re-create pktio interface for each test
>> cases.
>>
>> Regards,
>> Bala
>> Regards,
>> Bala
>>
> Agree. Initially I've done like proposed, but then look in
> odp_classification_tests.c,
> and see that mostly common pktio_loop is used. I will correct to set MAC
> addresses
> for each test, but odp_classification_tests.c should be sophisticated also,
> later.
>
>
>>
>> On 12 January 2016 at 23:41, Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
>> wrote:
>>>
>>> If pktion is in not promisc mode, a packet should contain correct
>>> MAC address.
>>>
>>> Signed-off-by: Ivan Khoronzhuk <ivan.khoronzhuk@linaro.org>
>>> ---
>>>   .../classification/odp_classification_test_pmr.c   | 158
>>> ++++++++++-----------
>>>   .../classification/odp_classification_tests.c      |  30 +++-
>>>   2 files changed, 96 insertions(+), 92 deletions(-)
>>>
>>> diff --git a/test/validation/classification/odp_classification_test_pmr.c
>>> b/test/validation/classification/odp_classification_test_pmr.c
>>> index 0b3f279..bb69794 100644
>>> --- a/test/validation/classification/odp_classification_test_pmr.c
>>> +++ b/test/validation/classification/odp_classification_test_pmr.c
>>> @@ -13,22 +13,11 @@
>>>   #include <odp/helper/tcp.h>
>>>
>>>   static odp_pool_t pkt_pool;
>>> +static odp_pktio_t pktio_loop;
>>>
>>>   /** sequence number of IP packets */
>>>   odp_atomic_u32_t seq;
>>>
>>> -int classification_suite_pmr_init(void)
>>> -{
>>> -       pkt_pool = pool_create("classification_pmr_pool");
>>> -       if (ODP_POOL_INVALID == pkt_pool) {
>>> -               fprintf(stderr, "Packet pool creation failed.\n");
>>> -               return -1;
>>> -       }
>>> -
>>> -       odp_atomic_init_u32(&seq, 0);
>>> -       return 0;
>>> -}
>>> -
>>>   odp_pktio_t create_pktio(odp_queue_type_t q_type)
>>>   {
>>>          odp_pktio_t pktio;
>>> @@ -55,6 +44,35 @@ odp_pktio_t create_pktio(odp_queue_type_t q_type)
>>>          return pktio;
>>>   }
>>>
>>> +int classification_suite_pmr_init(void)
>>> +{
>>> +       pkt_pool = pool_create("classification_pmr_pool");
>>> +       if (ODP_POOL_INVALID == pkt_pool) {
>>> +               fprintf(stderr, "Packet pool creation failed.\n");
>>> +               return -1;
>>> +       }
>>> +
>>> +       pktio_loop = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> +
>>> +       odp_atomic_init_u32(&seq, 0);
>>> +       return 0;
>>> +}
>>> +
>>> +static odp_packet_t
>>> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
>>> +{
>>> +       odp_packet_t pkt;
>>> +       odph_ethhdr_t *eth;
>>> +
>>> +       pkt = create_packet(pkt_pool, vlan, seq, flag_udp);
>>> +
>>> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
>>> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
>>> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
>>> +
>>> +       return pkt;
>>> +}
>>> +
>>>   void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
>>>                             odp_queue_t *queue, odp_pool_t *pool)
>>>   {
>>> @@ -93,6 +111,11 @@ int classification_suite_pmr_term(void)
>>>   {
>>>          int retcode = 0;
>>>
>>> +       if (odp_pktio_close(pktio_loop)) {
>>> +               fprintf(stderr, "unable to close pktio_loop.\n");
>>> +               retcode = -1;
>>> +       }
>>> +
>>>          if (0 != odp_pool_destroy(pkt_pool)) {
>>>                  fprintf(stderr, "pkt_pool destroy failed.\n");
>>>                  retcode = -1;
>>> @@ -109,7 +132,6 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          uint16_t val;
>>>          uint16_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -128,10 +150,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          mask = 0xffff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_TCP_DPORT;
>>> @@ -158,10 +177,10 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>>          CU_ASSERT(cos != ODP_COS_INVALID);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>>> +       pkt = cls_create_packet(false, &seq, false);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -169,7 +188,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -181,7 +200,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          odp_packet_free(pkt);
>>>
>>>          /* Other packets are delivered to default queue */
>>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>>> +       pkt = cls_create_packet(false, &seq, false);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -189,7 +208,7 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          tcp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -206,7 +225,6 @@ void classification_test_pmr_term_tcp_dport(void)
>>>          odp_queue_destroy(default_queue);
>>>          odp_pool_destroy(pool);
>>>          odp_pool_destroy(default_pool);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   void classification_test_pmr_term_tcp_sport(void)
>>> @@ -217,7 +235,6 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          uint16_t val;
>>>          uint16_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -235,10 +252,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          mask = 0xffff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_TCP_SPORT;
>>> @@ -264,10 +278,10 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>>> +       pkt = cls_create_packet(false, &seq, false);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -275,7 +289,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -285,7 +299,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          CU_ASSERT(recvpool == pool);
>>>          odp_packet_free(pkt);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>>> +       pkt = cls_create_packet(false, &seq, false);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -293,7 +307,7 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          tcp = (odph_tcphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          tcp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -310,7 +324,6 @@ void classification_test_pmr_term_tcp_sport(void)
>>>          odp_pool_destroy(pool);
>>>          odp_queue_destroy(queue);
>>>          odp_queue_destroy(default_queue);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   void classification_test_pmr_term_udp_dport(void)
>>> @@ -321,7 +334,6 @@ void classification_test_pmr_term_udp_dport(void)
>>>          uint16_t val;
>>>          uint16_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_pool_t pool;
>>>          odp_pool_t recvpool;
>>>          odp_queue_t queue;
>>> @@ -339,10 +351,7 @@ void classification_test_pmr_term_udp_dport(void)
>>>          mask = 0xffff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_UDP_DPORT;
>>> @@ -368,10 +377,10 @@ void classification_test_pmr_term_udp_dport(void)
>>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -379,7 +388,7 @@ void classification_test_pmr_term_udp_dport(void)
>>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -390,7 +399,7 @@ void classification_test_pmr_term_udp_dport(void)
>>>          odp_packet_free(pkt);
>>>
>>>          /* Other packets received in default queue */
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -398,7 +407,7 @@ void classification_test_pmr_term_udp_dport(void)
>>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          udp->dst_port = odp_cpu_to_be_16(CLS_DEFAULT_DPORT + 1);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -415,7 +424,6 @@ void classification_test_pmr_term_udp_dport(void)
>>>          odp_queue_destroy(default_queue);
>>>          odp_pool_destroy(default_pool);
>>>          odp_pool_destroy(pool);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   void classification_test_pmr_term_udp_sport(void)
>>> @@ -426,7 +434,6 @@ void classification_test_pmr_term_udp_sport(void)
>>>          uint16_t val;
>>>          uint16_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -444,10 +451,7 @@ void classification_test_pmr_term_udp_sport(void)
>>>          mask = 0xffff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_UDP_SPORT;
>>> @@ -473,10 +477,10 @@ void classification_test_pmr_term_udp_sport(void)
>>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -484,7 +488,7 @@ void classification_test_pmr_term_udp_sport(void)
>>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -494,7 +498,7 @@ void classification_test_pmr_term_udp_sport(void)
>>>          CU_ASSERT(recvpool == pool);
>>>          odp_packet_free(pkt);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -502,7 +506,7 @@ void classification_test_pmr_term_udp_sport(void)
>>>          udp = (odph_udphdr_t *)odp_packet_l4_ptr(pkt, NULL);
>>>          udp->src_port = odp_cpu_to_be_16(CLS_DEFAULT_SPORT + 1);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -519,7 +523,6 @@ void classification_test_pmr_term_udp_sport(void)
>>>          odp_pool_destroy(pool);
>>>          odp_queue_destroy(queue);
>>>          odp_queue_destroy(default_queue);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   void classification_test_pmr_term_ipproto(void)
>>> @@ -529,7 +532,6 @@ void classification_test_pmr_term_ipproto(void)
>>>          uint8_t val;
>>>          uint8_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -547,10 +549,7 @@ void classification_test_pmr_term_ipproto(void)
>>>          mask = 0xff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_IPPROTO;
>>> @@ -576,15 +575,15 @@ void classification_test_pmr_term_ipproto(void)
>>>          cos = odp_cls_cos_create(cosname, &cls_param);
>>>          CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -595,12 +594,12 @@ void classification_test_pmr_term_ipproto(void)
>>>          odp_packet_free(pkt);
>>>
>>>          /* Other packets delivered to default queue */
>>> -       pkt = create_packet(pkt_pool, false, &seq, false);
>>> +       pkt = cls_create_packet(false, &seq, false);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -617,7 +616,6 @@ void classification_test_pmr_term_ipproto(void)
>>>          odp_pool_destroy(pool);
>>>          odp_queue_destroy(queue);
>>>          odp_queue_destroy(default_queue);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   static void classification_test_pmr_pool_set(void)
>>> @@ -627,7 +625,6 @@ static void classification_test_pmr_pool_set(void)
>>>          uint8_t val;
>>>          uint8_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -646,10 +643,7 @@ static void classification_test_pmr_pool_set(void)
>>>          mask = 0xff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_IPPROTO;
>>> @@ -682,15 +676,15 @@ static void classification_test_pmr_pool_set(void)
>>>          retval = odp_cls_cos_pool_set(cos, pool_new);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -709,7 +703,6 @@ static void classification_test_pmr_pool_set(void)
>>>          odp_pool_destroy(pool_new);
>>>          odp_queue_destroy(queue);
>>>          odp_queue_destroy(default_queue);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   static void classification_test_pmr_queue_set(void)
>>> @@ -719,7 +712,6 @@ static void classification_test_pmr_queue_set(void)
>>>          uint8_t val;
>>>          uint8_t mask;
>>>          int retval;
>>> -       odp_pktio_t pktio;
>>>          odp_queue_t queue;
>>>          odp_queue_t retqueue;
>>>          odp_queue_t default_queue;
>>> @@ -738,10 +730,7 @@ static void classification_test_pmr_queue_set(void)
>>>          mask = 0xff;
>>>          seqno = 0;
>>>
>>> -       pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
>>> -       CU_ASSERT_FATAL(pktio != ODP_PKTIO_INVALID);
>>> -
>>> -       configure_default_cos(pktio, &default_cos,
>>> +       configure_default_cos(pktio_loop, &default_cos,
>>>                                &default_queue, &default_pool);
>>>
>>>          match.term = ODP_PMR_IPPROTO;
>>> @@ -774,15 +763,15 @@ static void classification_test_pmr_queue_set(void)
>>>          retval = odp_cos_queue_set(cos, queue_new);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       retval = odp_pktio_pmr_cos(pmr, pktio, cos);
>>> +       retval = odp_pktio_pmr_cos(pmr, pktio_loop, cos);
>>>          CU_ASSERT(retval == 0);
>>>
>>> -       pkt = create_packet(pkt_pool, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>>
>>> -       enqueue_pktio_interface(pkt, pktio);
>>> +       enqueue_pktio_interface(pkt, pktio_loop);
>>>
>>>          pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>> @@ -801,7 +790,6 @@ static void classification_test_pmr_queue_set(void)
>>>          odp_queue_destroy(queue_new);
>>>          odp_queue_destroy(queue);
>>>          odp_queue_destroy(default_queue);
>>> -       odp_pktio_close(pktio);
>>>   }
>>>
>>>   odp_testinfo_t classification_suite_pmr[] = {
>>> diff --git a/test/validation/classification/odp_classification_tests.c
>>> b/test/validation/classification/odp_classification_tests.c
>>> index a118728..34fc570 100644
>>> --- a/test/validation/classification/odp_classification_tests.c
>>> +++ b/test/validation/classification/odp_classification_tests.c
>>> @@ -118,6 +118,21 @@ int classification_suite_term(void)
>>>          return retcode;
>>>   }
>>>
>>> +static odp_packet_t
>>> +cls_create_packet(bool vlan, odp_atomic_u32_t *seq, bool flag_udp)
>>> +{
>>> +       odp_packet_t pkt;
>>> +       odph_ethhdr_t *eth;
>>> +
>>> +       pkt = create_packet(pool_default, vlan, seq, flag_udp);
>>> +
>>> +       eth = (odph_ethhdr_t *)odp_packet_l2_ptr(pkt, NULL);
>>> +       odp_pktio_mac_addr(pktio_loop, eth->src.addr, ODPH_ETHADDR_LEN);
>>> +       odp_pktio_mac_addr(pktio_loop, eth->dst.addr, ODPH_ETHADDR_LEN);
>>> +
>>> +       return pkt;
>>> +}
>>> +
>>>   void configure_cls_pmr_chain(void)
>>>   {
>>>          /* PKTIO --> PMR_SRC(SRC IP ADDR) --> PMR_DST (TCP SPORT) */
>>> @@ -225,7 +240,7 @@ void test_cls_pmr_chain(void)
>>>          uint32_t mask;
>>>          uint32_t seqno = 0;
>>>
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -248,7 +263,7 @@ void test_cls_pmr_chain(void)
>>>          CU_ASSERT(pool == pool_list[CLS_PMR_CHAIN_DST]);
>>>          odp_packet_free(pkt);
>>>
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -309,8 +324,9 @@ void test_pktio_default_cos(void)
>>>          odp_queue_t queue;
>>>          uint32_t seqno = 0;
>>>          odp_pool_t pool;
>>> +
>>>          /* create a default packet */
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -371,7 +387,7 @@ void test_pktio_error_cos(void)
>>>          odp_pool_t pool;
>>>
>>>          /*Create an error packet */
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          odph_ipv4hdr_t *ip = (odph_ipv4hdr_t *)odp_packet_l3_ptr(pkt,
>>> NULL);
>>>
>>> @@ -482,7 +498,7 @@ void test_cos_with_l2_priority(void)
>>>
>>>          uint8_t i;
>>>          for (i = 0; i < CLS_L2_QOS_MAX; i++) {
>>> -               pkt = create_packet(pool_default, true, &seq, true);
>>> +               pkt = cls_create_packet(true, &seq, true);
>>>                  CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>                  seqno = cls_pkt_get_seq(pkt);
>>>                  CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -557,7 +573,7 @@ void test_pmr_cos(void)
>>>          odp_pool_t pool;
>>>          uint32_t seqno = 0;
>>>
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> @@ -642,7 +658,7 @@ void test_pktio_pmr_match_set_cos(void)
>>>          odp_queue_t queue;
>>>          uint32_t seqno = 0;
>>>
>>> -       pkt = create_packet(pool_default, false, &seq, true);
>>> +       pkt = cls_create_packet(false, &seq, true);
>>>          CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID);
>>>          seqno = cls_pkt_get_seq(pkt);
>>>          CU_ASSERT(seqno != TEST_SEQ_INVALID);
>>> --
>>> 1.9.1
>>>
>
> --
> Regards,
> Ivan Khoronzhuk