api/validation/linux-generic: classification: implement class of service create api

Implements odp_cls_cos_create() and odp_cls_cos_param_init() functions and
replace odp_cos_create() function with odp_cls_cos_create() in validation
and examples.

Class of service create function now takes pool, queue, drop policy and
name as input parameters.
Adds class of service parameter structure odp_cls_cos_param_t and
initialization function odp_cls_cos_param_init()

Signed-off-by: Balasubramanian Manoharan <bala.manoharan@linaro.org>
Reviewed-by: Petri Savolainen <petri.savolainen@nokia.com>
Reviewed-and-tested-by: Bill Fischofer <bill.fischofer@linaro.org>
Signed-off-by: Maxim Uvarov <maxim.uvarov@linaro.org>

6 files changed, 453 insertions, 296 deletions

diff --git a/test/validation/classification/classification.h b/test/validation/classification/classification.h
index 99dbd65c..a186339f 100644
--- a/test/validation/classification/classification.h
+++ b/test/validation/classification/classification.h
@@ -59,6 +59,7 @@ void classification_test_destroy_cos(void);
 void classification_test_create_pmr_match(void);
 void classification_test_destroy_pmr(void);
 void classification_test_cos_set_queue(void);
+void classification_test_cos_set_pool(void);
 void classification_test_cos_set_drop(void);
 void classification_test_pmr_match_set_create(void);
 void classification_test_pmr_match_set_destroy(void);
diff --git a/test/validation/classification/odp_classification_basic.c b/test/validation/classification/odp_classification_basic.c
index 20c157f4..f0b7a424 100644
--- a/test/validation/classification/odp_classification_basic.c
+++ b/test/validation/classification/odp_classification_basic.c
@@ -13,26 +13,60 @@
 void classification_test_create_cos(void)
 {
 	odp_cos_t cos;
-	char name[ODP_COS_NAME_LEN];
-	sprintf(name, "ClassOfService");
-	cos = odp_cos_create(name);
-	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+	odp_cls_cos_param_t cls_param;
+	odp_pool_t pool;
+	odp_queue_t queue;
+	char cosname[ODP_COS_NAME_LEN];
+
+	pool = pool_create("cls_basic_pool");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	queue = queue_create("cls_basic_queue", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	sprintf(cosname, "ClassOfService");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
 	CU_ASSERT(odp_cos_to_u64(cos) != odp_cos_to_u64(ODP_COS_INVALID));
 	odp_cos_destroy(cos);
+	odp_pool_destroy(pool);
+	odp_queue_destroy(queue);
 }
 
 void classification_test_destroy_cos(void)
 {
 	odp_cos_t cos;
 	char name[ODP_COS_NAME_LEN];
+	odp_pool_t pool;
+	odp_queue_t queue;
+	odp_cls_cos_param_t cls_param;
 	int retval;
+
+	pool = pool_create("cls_basic_pool");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	queue = queue_create("cls_basic_queue", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
 	sprintf(name, "ClassOfService");
-	cos = odp_cos_create(name);
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(name, &cls_param);
 	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
 	retval = odp_cos_destroy(cos);
 	CU_ASSERT(retval == 0);
 	retval = odp_cos_destroy(ODP_COS_INVALID);
 	CU_ASSERT(retval < 0);
+
+	odp_pool_destroy(pool);
+	odp_queue_destroy(queue);
 }
 
 void classification_test_create_pmr_match(void)
@@ -82,35 +116,101 @@ void classification_test_cos_set_queue(void)
 {
 	int retval;
 	char cosname[ODP_COS_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
-	odp_queue_param_t qparam;
+	odp_cls_cos_param_t cls_param;
+	odp_pool_t pool;
+	odp_queue_t queue;
 	odp_queue_t queue_cos;
 	odp_cos_t cos_queue;
+	odp_queue_t recvqueue;
+
+	pool = pool_create("cls_basic_pool");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	queue = queue_create("cls_basic_queue", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
 	sprintf(cosname, "CoSQueue");
-	cos_queue = odp_cos_create(cosname);
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_queue = odp_cls_cos_create(cosname, &cls_param);
 	CU_ASSERT_FATAL(cos_queue != ODP_COS_INVALID);
 
-	odp_queue_param_init(&qparam);
-	qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
-	qparam.sched.sync = ODP_SCHED_SYNC_NONE;
-	qparam.sched.group = ODP_SCHED_GROUP_ALL;
-	sprintf(queuename, "%s", "QueueCoS");
+	queue_cos = queue_create("QueueCoS", true);
+	CU_ASSERT_FATAL(queue_cos != ODP_QUEUE_INVALID);
 
-	queue_cos = odp_queue_create(queuename,
-				     ODP_QUEUE_TYPE_SCHED, &qparam);
 	retval = odp_cos_queue_set(cos_queue, queue_cos);
 	CU_ASSERT(retval == 0);
+	recvqueue = odp_cos_queue(cos_queue);
+	CU_ASSERT(recvqueue == queue_cos);
+
 	odp_cos_destroy(cos_queue);
 	odp_queue_destroy(queue_cos);
+	odp_queue_destroy(queue);
+	odp_pool_destroy(pool);
+}
+
+void classification_test_cos_set_pool(void)
+{
+	int retval;
+	char cosname[ODP_COS_NAME_LEN];
+	odp_cls_cos_param_t cls_param;
+	odp_pool_t pool;
+	odp_queue_t queue;
+	odp_pool_t cos_pool;
+	odp_cos_t cos;
+	odp_pool_t recvpool;
+
+	pool = pool_create("cls_basic_pool");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	queue = queue_create("cls_basic_queue", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	sprintf(cosname, "CoSQueue");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+	cos_pool = pool_create("PoolCoS");
+	CU_ASSERT_FATAL(cos_pool != ODP_POOL_INVALID);
+
+	retval = odp_cls_cos_pool_set(cos, cos_pool);
+	CU_ASSERT(retval == 0);
+	recvpool = odp_cls_cos_pool(cos);
+	CU_ASSERT(recvpool == cos_pool);
+
+	odp_cos_destroy(cos);
+	odp_queue_destroy(queue);
+	odp_pool_destroy(pool);
+	odp_pool_destroy(cos_pool);
 }
 
 void classification_test_cos_set_drop(void)
 {
 	int retval;
 	char cosname[ODP_COS_NAME_LEN];
-	sprintf(cosname, "CoSDrop");
 	odp_cos_t cos_drop;
-	cos_drop = odp_cos_create(cosname);
+	odp_queue_t queue;
+	odp_pool_t pool;
+	odp_cls_cos_param_t cls_param;
+
+	pool = pool_create("cls_basic_pool");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	queue = queue_create("cls_basic_queue", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	sprintf(cosname, "CoSDrop");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_drop = odp_cls_cos_create(cosname, &cls_param);
 	CU_ASSERT_FATAL(cos_drop != ODP_COS_INVALID);
 
 	retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_POOL);
@@ -118,6 +218,8 @@ void classification_test_cos_set_drop(void)
 	retval = odp_cos_drop_set(cos_drop, ODP_COS_DROP_NEVER);
 	CU_ASSERT(retval == 0);
 	odp_cos_destroy(cos_drop);
+	odp_pool_destroy(pool);
+	odp_queue_destroy(queue);
 }
 
 void classification_test_pmr_match_set_create(void)
@@ -177,6 +279,7 @@ odp_testinfo_t classification_suite_basic[] = {
 	ODP_TEST_INFO(classification_test_destroy_pmr),
 	ODP_TEST_INFO(classification_test_cos_set_queue),
 	ODP_TEST_INFO(classification_test_cos_set_drop),
+	ODP_TEST_INFO(classification_test_cos_set_pool),
 	ODP_TEST_INFO(classification_test_pmr_match_set_create),
 	ODP_TEST_INFO(classification_test_pmr_match_set_destroy),
 	ODP_TEST_INFO_NULL,
diff --git a/test/validation/classification/odp_classification_common.c b/test/validation/classification/odp_classification_common.c
index a56c017f..afcea454 100644
--- a/test/validation/classification/odp_classification_common.c
+++ b/test/validation/classification/odp_classification_common.c
@@ -154,7 +154,7 @@ odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns)
 	return odp_packet_from_event(ev);
 }
 
-odp_queue_t queue_create(char *queuename, bool sched)
+odp_queue_t queue_create(const char *queuename, bool sched)
 {
 	odp_queue_t queue;
 	odp_queue_param_t qparam;
@@ -177,6 +177,19 @@ odp_queue_t queue_create(char *queuename, bool sched)
 	return queue;
 }
 
+odp_pool_t pool_create(const char *poolname)
+{
+	odp_pool_param_t param;
+
+	odp_pool_param_init(&param);
+	param.pkt.seg_len = SHM_PKT_BUF_SIZE;
+	param.pkt.len     = SHM_PKT_BUF_SIZE;
+	param.pkt.num     = SHM_PKT_NUM_BUFS;
+	param.type        = ODP_POOL_PACKET;
+
+	return odp_pool_create(poolname, &param);
+}
+
 odp_packet_t create_packet(odp_pool_t pool, bool vlan,
 			   odp_atomic_u32_t *seq, bool flag_udp)
 {
diff --git a/test/validation/classification/odp_classification_test_pmr.c b/test/validation/classification/odp_classification_test_pmr.c
index f267ff86..5a13e136 100644
--- a/test/validation/classification/odp_classification_test_pmr.c
+++ b/test/validation/classification/odp_classification_test_pmr.c
@@ -19,15 +19,7 @@ odp_atomic_u32_t seq;
 
 int classification_suite_pmr_init(void)
 {
-	odp_pool_param_t param;
-
-	odp_pool_param_init(&param);
-	param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	param.pkt.len     = SHM_PKT_BUF_SIZE;
-	param.pkt.num     = SHM_PKT_NUM_BUFS;
-	param.type        = ODP_POOL_PACKET;
-
-	pkt_pool = odp_pool_create("classification_pmr_pool", &param);
+	pkt_pool = pool_create("classification_pmr_pool");
 	if (ODP_POOL_INVALID == pkt_pool) {
 		fprintf(stderr, "Packet pool creation failed.\n");
 		return -1;
@@ -99,38 +91,27 @@ int create_default_inq(odp_pktio_t pktio, odp_queue_type_t qtype)
 void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
 			   odp_queue_t *queue, odp_pool_t *pool)
 {
-	odp_pool_param_t pool_param;
+	odp_cls_cos_param_t cls_param;
 	odp_pool_t default_pool;
 	odp_cos_t default_cos;
 	odp_queue_t default_queue;
 	int retval;
 	char cosname[ODP_COS_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
 
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "DefaultPool");
-
-	default_pool  = odp_pool_create(poolname, &pool_param);
+	default_pool  = pool_create("DefaultPool");
 	CU_ASSERT(default_pool != ODP_POOL_INVALID);
 
-	sprintf(queuename, "DefaultQueue");
-	default_queue = queue_create(queuename, true);
+	default_queue = queue_create("DefaultQueue", true);
 	CU_ASSERT(default_queue != ODP_QUEUE_INVALID);
 
 	sprintf(cosname, "DefaultCos");
-	default_cos = odp_cos_create(cosname);
-	CU_ASSERT(default_cos != ODP_COS_INVALID);
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = default_pool;
+	cls_param.queue = default_queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
 
-	retval = odp_cos_queue_set(default_cos, default_queue);
-	CU_ASSERT(retval == 0);
-
-	retval = odp_cls_cos_pool_set(default_cos, default_pool);
-	CU_ASSERT(retval == 0);
+	default_cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT(default_cos != ODP_COS_INVALID);
 
 	retval = odp_pktio_default_cos_set(pktio, default_cos);
 	CU_ASSERT(retval == 0);
@@ -171,9 +152,7 @@ void classification_test_pmr_term_tcp_dport(void)
 	odp_pmr_t pmr;
 	odp_cos_t cos;
 	char cosname[ODP_COS_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	odp_pool_param_t pool_param;
+	odp_cls_cos_param_t cls_param;
 	odp_pool_t pool;
 	odp_pool_t pool_recv;
 	odp_pmr_match_t match;
@@ -195,30 +174,21 @@ void classification_test_pmr_term_tcp_dport(void)
 	pmr = odp_pmr_create(&match);
 	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
-	sprintf(cosname, "tcp_dport");
-	cos = odp_cos_create(cosname);
-	CU_ASSERT(cos != ODP_COS_INVALID);
-
-	sprintf(queuename, "%s", "tcp_dport1");
 
-	queue = queue_create(queuename, true);
+	queue = queue_create("tcp_dport1", true);
 	CU_ASSERT(queue != ODP_QUEUE_INVALID);
 
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "tcp_dport1");
-
-	pool = odp_pool_create(poolname, &pool_param);
+	pool = pool_create("tcp_dport1");
 	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos, pool);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "tcp_dport");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
 
-	retval = odp_cos_queue_set(cos, queue);
-	CU_ASSERT(retval == 0);
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT(cos != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
 	CU_ASSERT(retval == 0);
@@ -286,14 +256,12 @@ void classification_test_pmr_term_tcp_sport(void)
 	odp_queue_t default_queue;
 	odp_cos_t default_cos;
 	odp_pool_t default_pool;
-	odp_pool_param_t pool_param;
 	odp_pool_t pool;
 	odp_pool_t recvpool;
 	odp_pmr_t pmr;
 	odp_cos_t cos;
 	char cosname[ODP_COS_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
+	odp_cls_cos_param_t cls_param;
 	odp_pmr_match_t match;
 
 	val = CLS_DEFAULT_SPORT;
@@ -312,30 +280,20 @@ void classification_test_pmr_term_tcp_sport(void)
 	pmr = odp_pmr_create(&match);
 	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
-	sprintf(cosname, "tcp_sport");
-	cos = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
-	sprintf(queuename, "%s", "tcp_sport");
-
-	queue = queue_create(queuename, true);
+	queue = queue_create("tcp_sport", true);
 	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
 
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "tcp_sport");
-
-	pool = odp_pool_create(poolname, &pool_param);
+	pool = pool_create("tcp_sport");
 	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos, pool);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "tcp_sport");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
 
-	retval = odp_cos_queue_set(cos, queue);
-	CU_ASSERT(retval == 0);
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
 	CU_ASSERT(retval == 0);
@@ -403,13 +361,11 @@ void classification_test_pmr_term_udp_dport(void)
 	odp_queue_t default_queue;
 	odp_cos_t default_cos;
 	odp_pool_t default_pool;
-	odp_pool_param_t pool_param;
 	odp_pmr_t pmr;
 	odp_cos_t cos;
 	char cosname[ODP_COS_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
 	odp_pmr_match_t match;
+	odp_cls_cos_param_t cls_param;
 
 	val = CLS_DEFAULT_DPORT;
 	mask = 0xffff;
@@ -427,30 +383,20 @@ void classification_test_pmr_term_udp_dport(void)
 	pmr = odp_pmr_create(&match);
 	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
-	sprintf(cosname, "udp_dport");
-	cos = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
-	sprintf(queuename, "%s", "udp_dport");
-
-	queue = queue_create(queuename, true);
+	queue = queue_create("udp_dport", true);
 	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos, queue);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "udp_dport");
-
-	pool = odp_pool_create(poolname, &pool_param);
+	pool = pool_create("udp_dport");
 	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos, pool);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "udp_dport");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
 	CU_ASSERT(retval == 0);
@@ -517,15 +463,13 @@ void classification_test_pmr_term_udp_sport(void)
 	odp_queue_t default_queue;
 	odp_cos_t default_cos;
 	odp_pool_t default_pool;
-	odp_pool_param_t pool_param;
 	odp_pool_t pool;
 	odp_pool_t recvpool;
 	odp_pmr_t pmr;
 	odp_cos_t cos;
 	char cosname[ODP_COS_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
 	odp_pmr_match_t match;
+	odp_cls_cos_param_t cls_param;
 
 	val = CLS_DEFAULT_SPORT;
 	mask = 0xffff;
@@ -543,30 +487,20 @@ void classification_test_pmr_term_udp_sport(void)
 	pmr = odp_pmr_create(&match);
 	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
-	sprintf(cosname, "udp_sport");
-	cos = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
-
-	sprintf(queuename, "%s", "udp_sport");
-
-	queue = queue_create(queuename, true);
+	queue = queue_create("udp_sport", true);
 	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos, queue);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "udp_sport");
-
-	pool = odp_pool_create(poolname, &pool_param);
+	pool = pool_create("udp_sport");
 	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos, pool);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "udp_sport");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
 	CU_ASSERT(retval == 0);
@@ -635,10 +569,8 @@ void classification_test_pmr_term_ipproto(void)
 	odp_pool_t recvpool;
 	odp_pmr_t pmr;
 	odp_cos_t cos;
-	odp_pool_param_t pool_param;
 	char cosname[ODP_COS_NAME_LEN];
-	char poolname[ODP_POOL_NAME_LEN];
-	char queuename[ODP_QUEUE_NAME_LEN];
+	odp_cls_cos_param_t cls_param;
 	odp_pmr_match_t match;
 
 	val = ODPH_IPPROTO_UDP;
@@ -657,29 +589,124 @@ void classification_test_pmr_term_ipproto(void)
 	pmr = odp_pmr_create(&match);
 	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
+	queue = queue_create("ipproto", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	pool = pool_create("ipproto");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
 	sprintf(cosname, "ipproto");
-	cos = odp_cos_create(cosname);
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
 	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
 
-	sprintf(queuename, "%s", "ipproto");
+	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
+	CU_ASSERT(retval == 0);
 
-	queue = queue_create(queuename, true);
-	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+	configure_default_cos(pktio, &default_cos,
+			      &default_queue, &default_pool);
+	pkt = create_packet(pkt_pool, false, &seq, true);
+	seqno = cls_pkt_get_seq(pkt);
+	CU_ASSERT(seqno != TEST_SEQ_INVALID);
+
+	enqueue_pktio_interface(pkt, pktio);
+
+	pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+	CU_ASSERT(pkt != ODP_PACKET_INVALID);
+	CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+	recvpool = odp_packet_pool(pkt);
+	CU_ASSERT(recvpool == pool);
+	CU_ASSERT(retqueue == queue);
+	odp_packet_free(pkt);
+
+	/* Other packets delivered to default queue */
+	pkt = create_packet(pkt_pool, false, &seq, false);
+	seqno = cls_pkt_get_seq(pkt);
+	CU_ASSERT(seqno != TEST_SEQ_INVALID);
+
+	enqueue_pktio_interface(pkt, pktio);
+
+	pkt = receive_packet(&retqueue, ODP_TIME_SEC_IN_NS);
+	CU_ASSERT(pkt != ODP_PACKET_INVALID);
+	CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
+	recvpool = odp_packet_pool(pkt);
+	CU_ASSERT(recvpool == default_pool);
+	CU_ASSERT(retqueue == default_queue);
+
+	odp_cos_destroy(cos);
+	odp_cos_destroy(default_cos);
+	odp_pmr_destroy(pmr);
+	odp_packet_free(pkt);
+	destroy_inq(pktio);
+	odp_pool_destroy(default_pool);
+	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)
+{
+	odp_packet_t pkt;
+	uint32_t seqno;
+	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;
+	odp_cos_t default_cos;
+	odp_pool_t default_pool;
+	odp_pool_t pool;
+	odp_pool_t pool_new;
+	odp_pool_t recvpool;
+	odp_pmr_t pmr;
+	odp_cos_t cos;
+	char cosname[ODP_COS_NAME_LEN];
+	odp_cls_cos_param_t cls_param;
+	odp_pmr_match_t match;
 
-	retval = odp_cos_queue_set(cos, queue);
+	val = ODPH_IPPROTO_UDP;
+	mask = 0xff;
+	seqno = 0;
+
+	pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
+	retval = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED);
 	CU_ASSERT(retval == 0);
 
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-	sprintf(poolname, "%s", "ipproto");
+	match.term = ODP_PMR_IPPROTO;
+	match.val = &val;
+	match.mask = &mask;
+	match.val_sz = sizeof(val);
+
+	pmr = odp_pmr_create(&match);
+	CU_ASSERT(pmr != ODP_PMR_INVAL);
 
-	pool = odp_pool_create(poolname, &pool_param);
+	queue = queue_create("ipproto1", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	pool = pool_create("ipproto1");
 	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos, pool);
+	sprintf(cosname, "ipproto1");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+	pool_new = pool_create("ipproto2");
+	CU_ASSERT_FATAL(pool_new != ODP_POOL_INVALID);
+
+	/* new pool is set on CoS */
+	retval = odp_cls_cos_pool_set(cos, pool_new);
 	CU_ASSERT(retval == 0);
 
 	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
@@ -697,12 +724,89 @@ void classification_test_pmr_term_ipproto(void)
 	CU_ASSERT(pkt != ODP_PACKET_INVALID);
 	CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
 	recvpool = odp_packet_pool(pkt);
-	CU_ASSERT(recvpool == pool);
+	CU_ASSERT(recvpool == pool_new);
 	CU_ASSERT(retqueue == queue);
 	odp_packet_free(pkt);
 
-	/* Other packets delivered to default queue */
-	pkt = create_packet(pkt_pool, false, &seq, false);
+	odp_cos_destroy(cos);
+	odp_cos_destroy(default_cos);
+	odp_pmr_destroy(pmr);
+	odp_packet_free(pkt);
+	destroy_inq(pktio);
+	odp_pool_destroy(default_pool);
+	odp_pool_destroy(pool);
+	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)
+{
+	odp_packet_t pkt;
+	uint32_t seqno;
+	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;
+	odp_cos_t default_cos;
+	odp_pool_t default_pool;
+	odp_pool_t pool;
+	odp_queue_t queue_new;
+	odp_pool_t recvpool;
+	odp_pmr_t pmr;
+	odp_cos_t cos;
+	char cosname[ODP_COS_NAME_LEN];
+	odp_cls_cos_param_t cls_param;
+	odp_pmr_match_t match;
+
+	val = ODPH_IPPROTO_UDP;
+	mask = 0xff;
+	seqno = 0;
+
+	pktio = create_pktio(ODP_QUEUE_TYPE_SCHED);
+	retval = create_default_inq(pktio, ODP_QUEUE_TYPE_SCHED);
+	CU_ASSERT(retval == 0);
+
+	match.term = ODP_PMR_IPPROTO;
+	match.val = &val;
+	match.mask = &mask;
+	match.val_sz = sizeof(val);
+
+	pmr = odp_pmr_create(&match);
+	CU_ASSERT(pmr != ODP_PMR_INVAL);
+
+	queue = queue_create("ipproto1", true);
+	CU_ASSERT_FATAL(queue != ODP_QUEUE_INVALID);
+
+	pool = pool_create("ipproto1");
+	CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
+
+	sprintf(cosname, "ipproto1");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool;
+	cls_param.queue = queue;
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+
+	cos = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos != ODP_COS_INVALID);
+
+	queue_new = queue_create("ipproto2", true);
+	CU_ASSERT_FATAL(queue_new != ODP_QUEUE_INVALID);
+
+	/* new queue is set on CoS */
+	retval = odp_cos_queue_set(cos, queue_new);
+	CU_ASSERT(retval == 0);
+
+	retval = odp_pktio_pmr_cos(pmr, pktio, cos);
+	CU_ASSERT(retval == 0);
+
+	configure_default_cos(pktio, &default_cos,
+			      &default_queue, &default_pool);
+	pkt = create_packet(pkt_pool, false, &seq, true);
 	seqno = cls_pkt_get_seq(pkt);
 	CU_ASSERT(seqno != TEST_SEQ_INVALID);
 
@@ -712,8 +816,9 @@ void classification_test_pmr_term_ipproto(void)
 	CU_ASSERT(pkt != ODP_PACKET_INVALID);
 	CU_ASSERT(seqno == cls_pkt_get_seq(pkt));
 	recvpool = odp_packet_pool(pkt);
-	CU_ASSERT(recvpool == default_pool);
-	CU_ASSERT(retqueue == default_queue);
+	CU_ASSERT(recvpool == pool);
+	CU_ASSERT(retqueue == queue_new);
+	odp_packet_free(pkt);
 
 	odp_cos_destroy(cos);
 	odp_cos_destroy(default_cos);
@@ -722,6 +827,7 @@ void classification_test_pmr_term_ipproto(void)
 	destroy_inq(pktio);
 	odp_pool_destroy(default_pool);
 	odp_pool_destroy(pool);
+	odp_queue_destroy(queue_new);
 	odp_queue_destroy(queue);
 	odp_queue_destroy(default_queue);
 	odp_pktio_close(pktio);
@@ -733,5 +839,7 @@ odp_testinfo_t classification_suite_pmr[] = {
 	ODP_TEST_INFO(classification_test_pmr_term_udp_dport),
 	ODP_TEST_INFO(classification_test_pmr_term_udp_sport),
 	ODP_TEST_INFO(classification_test_pmr_term_ipproto),
+	ODP_TEST_INFO(classification_test_pmr_pool_set),
+	ODP_TEST_INFO(classification_test_pmr_queue_set),
 	ODP_TEST_INFO_NULL,
 };
diff --git a/test/validation/classification/odp_classification_tests.c b/test/validation/classification/odp_classification_tests.c
index b64d8418..99242d09 100644
--- a/test/validation/classification/odp_classification_tests.c
+++ b/test/validation/classification/odp_classification_tests.c
@@ -25,7 +25,6 @@ odp_atomic_u32_t seq;
 
 int classification_suite_init(void)
 {
-	odp_pool_param_t param;
 	odp_queue_t inq_def;
 	odp_queue_param_t qparam;
 	char queuename[ODP_QUEUE_NAME_LEN];
@@ -33,13 +32,7 @@ int classification_suite_init(void)
 	int ret;
 	odp_pktio_param_t pktio_param;
 
-	odp_pool_param_init(&param);
-	param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	param.pkt.len     = SHM_PKT_BUF_SIZE;
-	param.pkt.num     = SHM_PKT_NUM_BUFS;
-	param.type        = ODP_POOL_PACKET;
-
-	pool_default = odp_pool_create("classification_pool", &param);
+	pool_default = pool_create("classification_pool");
 	if (ODP_POOL_INVALID == pool_default) {
 		fprintf(stderr, "Packet pool creation failed.\n");
 		return -1;
@@ -55,6 +48,7 @@ int classification_suite_init(void)
 			fprintf(stderr, "unable to destroy pool.\n");
 		return -1;
 	}
+
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio  = ODP_SCHED_PRIO_DEFAULT;
 	qparam.sched.sync  = ODP_SCHED_SYNC_ATOMIC;
@@ -136,16 +130,13 @@ void configure_cls_pmr_chain(void)
 	int retval;
 	char cosname[ODP_QUEUE_NAME_LEN];
 	odp_queue_param_t qparam;
-	odp_pool_param_t pool_param;
+	odp_cls_cos_param_t cls_param;
 	char queuename[ODP_QUEUE_NAME_LEN];
 	char poolname[ODP_POOL_NAME_LEN];
 	uint32_t addr;
 	uint32_t mask;
 	odp_pmr_match_t match;
 
-	sprintf(cosname, "SrcCos");
-	cos_list[CLS_PMR_CHAIN_SRC] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_SRC] != ODP_COS_INVALID);
 
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
@@ -160,27 +151,18 @@ void configure_cls_pmr_chain(void)
 
 	CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_SRC] != ODP_QUEUE_INVALID);
 
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "%s", "SrcPool");
-
-	pool_list[CLS_PMR_CHAIN_SRC] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_PMR_CHAIN_SRC] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_PMR_CHAIN_SRC] != ODP_POOL_INVALID);
 
-	retval = odp_cos_queue_set(cos_list[CLS_PMR_CHAIN_SRC],
-				   queue_list[CLS_PMR_CHAIN_SRC]);
-	CU_ASSERT(retval == 0);
-
-	retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_CHAIN_SRC],
-				      pool_list[CLS_PMR_CHAIN_SRC]);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "SrcCos");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_PMR_CHAIN_SRC];
+	cls_param.queue = queue_list[CLS_PMR_CHAIN_SRC];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_PMR_CHAIN_SRC] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_SRC] != ODP_COS_INVALID);
 
-	sprintf(cosname, "DstCos");
-	cos_list[CLS_PMR_CHAIN_DST] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_DST] != ODP_COS_INVALID);
 
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio = ODP_SCHED_PRIO_NORMAL;
@@ -193,23 +175,17 @@ void configure_cls_pmr_chain(void)
 						     &qparam);
 	CU_ASSERT_FATAL(queue_list[CLS_PMR_CHAIN_DST] != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos_list[CLS_PMR_CHAIN_DST],
-				   queue_list[CLS_PMR_CHAIN_DST]);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "%s", "DstPool");
-
-	pool_list[CLS_PMR_CHAIN_DST] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_PMR_CHAIN_DST] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_PMR_CHAIN_DST] != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_CHAIN_DST],
-				      pool_list[CLS_PMR_CHAIN_DST]);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "DstCos");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_PMR_CHAIN_DST];
+	cls_param.queue = queue_list[CLS_PMR_CHAIN_DST];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_PMR_CHAIN_DST] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_PMR_CHAIN_DST] != ODP_COS_INVALID);
 
 	parse_ipv4_string(CLS_PMR_CHAIN_SADDR, &addr, &mask);
 	match.term = ODP_PMR_SIP_ADDR;
@@ -296,15 +272,11 @@ void configure_pktio_default_cos(void)
 {
 	int retval;
 	odp_queue_param_t qparam;
-	odp_pool_param_t pool_param;
+	odp_cls_cos_param_t cls_param;
 	char cosname[ODP_COS_NAME_LEN];
 	char queuename[ODP_QUEUE_NAME_LEN];
 	char poolname[ODP_POOL_NAME_LEN];
 
-	sprintf(cosname, "DefaultCoS");
-	cos_list[CLS_DEFAULT] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);
-
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio = ODP_SCHED_PRIO_DEFAULT;
 	qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -314,23 +286,17 @@ void configure_pktio_default_cos(void)
 					 ODP_QUEUE_TYPE_SCHED, &qparam);
 	CU_ASSERT_FATAL(queue_list[CLS_DEFAULT] != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos_list[CLS_DEFAULT],
-				   queue_list[CLS_DEFAULT]);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "DefaultPool");
-
-	pool_list[CLS_DEFAULT] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_DEFAULT] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_DEFAULT] != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos_list[CLS_DEFAULT],
-				      pool_list[CLS_DEFAULT]);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "DefaultCoS");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_DEFAULT];
+	cls_param.queue = queue_list[CLS_DEFAULT];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_DEFAULT] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_DEFAULT] != ODP_COS_INVALID);
 
 	retval = odp_pktio_default_cos_set(pktio_loop, cos_list[CLS_DEFAULT]);
 	CU_ASSERT(retval == 0);
@@ -364,7 +330,7 @@ void configure_pktio_error_cos(void)
 {
 	int retval;
 	odp_queue_param_t qparam;
-	odp_pool_param_t pool_param;
+	odp_cls_cos_param_t cls_param;
 	char queuename[ODP_QUEUE_NAME_LEN];
 	char cosname[ODP_COS_NAME_LEN];
 	char poolname[ODP_POOL_NAME_LEN];
@@ -380,26 +346,17 @@ void configure_pktio_error_cos(void)
 						 &qparam);
 	CU_ASSERT_FATAL(queue_list[CLS_ERROR] != ODP_QUEUE_INVALID);
 
-	sprintf(cosname, "%s", "ErrorCos");
-	cos_list[CLS_ERROR] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);
-
-	retval = odp_cos_queue_set(cos_list[CLS_ERROR], queue_list[CLS_ERROR]);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "ErrorPool");
-
-	pool_list[CLS_ERROR] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_ERROR] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_ERROR] != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos_list[CLS_ERROR],
-				      pool_list[CLS_ERROR]);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "%s", "ErrorCos");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_ERROR];
+	cls_param.queue = queue_list[CLS_ERROR];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_ERROR] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_ERROR] != ODP_COS_INVALID);
 
 	retval = odp_pktio_error_cos_set(pktio_loop, cos_list[CLS_ERROR]);
 	CU_ASSERT(retval == 0);
@@ -471,14 +428,7 @@ void configure_cos_with_l2_priority(void)
 	int retval;
 	int i;
 	odp_queue_param_t qparam;
-	odp_pool_param_t pool_param;
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
-
+	odp_cls_cos_param_t cls_param;
 
 	/** Initialize scalar variable qos_tbl **/
 	for (i = 0; i < CLS_L2_QOS_MAX; i++)
@@ -489,32 +439,31 @@ void configure_cos_with_l2_priority(void)
 	qparam.sched.group = ODP_SCHED_GROUP_ALL;
 	for (i = 0; i < num_qos; i++) {
 		qparam.sched.prio = ODP_SCHED_PRIO_LOWEST - i;
-		sprintf(cosname, "%s_%d", "L2_Cos", i);
-		cos_tbl[i] = odp_cos_create(cosname);
-		if (cos_tbl[i] == ODP_COS_INVALID)
-			break;
-
-		cos_list[CLS_L2_QOS_0 + i] = cos_tbl[i];
 		sprintf(queuename, "%s_%d", "L2_Queue", i);
 		queue_tbl[i] = odp_queue_create(queuename, ODP_QUEUE_TYPE_SCHED,
 					      &qparam);
 		CU_ASSERT_FATAL(queue_tbl[i] != ODP_QUEUE_INVALID);
 		queue_list[CLS_L2_QOS_0 + i] = queue_tbl[i];
 
-		retval = odp_cos_queue_set(cos_tbl[i], queue_tbl[i]);
-		CU_ASSERT(retval == 0);
-
 		sprintf(poolname, "%s_%d", "L2_Pool", i);
-		pool = odp_pool_create(poolname, &pool_param);
+		pool = pool_create(poolname);
 		CU_ASSERT_FATAL(pool != ODP_POOL_INVALID);
 		pool_list[CLS_L2_QOS_0 + i] = pool;
-		retval = odp_cls_cos_pool_set(cos_tbl[i], pool);
-		CU_ASSERT(retval == 0);
 
+		sprintf(cosname, "%s_%d", "L2_Cos", i);
+		odp_cls_cos_param_init(&cls_param);
+		cls_param.pool = pool;
+		cls_param.queue = queue_tbl[i];
+		cls_param.drop_policy = ODP_COS_DROP_POOL;
+		cos_tbl[i] = odp_cls_cos_create(cosname, &cls_param);
+		if (cos_tbl[i] == ODP_COS_INVALID)
+			break;
+
+		cos_list[CLS_L2_QOS_0 + i] = cos_tbl[i];
 		qos_tbl[i] = i;
 	}
 	/* count 'i' is passed instead of num_qos to handle the rare scenario
-	if the odp_cos_create() failed in the middle*/
+	if the odp_cls_cos_create() failed in the middle*/
 	retval = odp_cos_with_l2_priority(pktio_loop, i, qos_tbl, cos_tbl);
 	CU_ASSERT(retval == 0);
 }
@@ -554,10 +503,10 @@ void configure_pmr_cos(void)
 	int retval;
 	odp_pmr_match_t match;
 	odp_queue_param_t qparam;
+	odp_cls_cos_param_t cls_param;
 	char cosname[ODP_COS_NAME_LEN];
 	char queuename[ODP_QUEUE_NAME_LEN];
 	char poolname[ODP_POOL_NAME_LEN];
-	odp_pool_param_t pool_param;
 
 	val = CLS_PMR_SPORT;
 	mask = 0xffff;
@@ -569,10 +518,6 @@ void configure_pmr_cos(void)
 	pmr_list[CLS_PMR] = odp_pmr_create(&match);
 	CU_ASSERT(pmr_list[CLS_PMR] != ODP_PMR_INVAL);
 
-	sprintf(cosname, "PMR_CoS");
-	cos_list[CLS_PMR] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_PMR] != ODP_COS_INVALID);
-
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
 	qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -584,22 +529,17 @@ void configure_pmr_cos(void)
 					       &qparam);
 	CU_ASSERT_FATAL(queue_list[CLS_PMR] != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos_list[CLS_PMR],
-				   queue_list[CLS_PMR]);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "PMR_Pool");
-
-	pool_list[CLS_PMR] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_PMR] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_PMR] != ODP_POOL_INVALID);
 
-	retval = odp_cls_cos_pool_set(cos_list[CLS_PMR], pool_list[CLS_PMR]);
-	CU_ASSERT(retval == 0);
+	sprintf(cosname, "PMR_CoS");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_PMR];
+	cls_param.queue = queue_list[CLS_PMR];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_PMR] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_PMR] != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_cos(pmr_list[CLS_PMR], pktio_loop,
 				   cos_list[CLS_PMR]);
@@ -637,10 +577,10 @@ void configure_pktio_pmr_match_set_cos(void)
 	uint16_t maskport;
 	int num_terms = 2; /* one pmr for each L3 and L4 */
 	odp_queue_param_t qparam;
+	odp_cls_cos_param_t cls_param;
 	char cosname[ODP_COS_NAME_LEN];
 	char queuename[ODP_QUEUE_NAME_LEN];
 	char poolname[ODP_POOL_NAME_LEN];
-	odp_pool_param_t pool_param;
 	uint32_t addr = 0;
 	uint32_t mask;
 
@@ -661,10 +601,6 @@ void configure_pktio_pmr_match_set_cos(void)
 	retval = odp_pmr_match_set_create(num_terms, pmr_terms, &pmr_set);
 	CU_ASSERT(retval > 0);
 
-	sprintf(cosname, "cos_pmr_set");
-	cos_list[CLS_PMR_SET] = odp_cos_create(cosname);
-	CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID);
-
 	odp_queue_param_init(&qparam);
 	qparam.sched.prio = ODP_SCHED_PRIO_HIGHEST;
 	qparam.sched.sync = ODP_SCHED_SYNC_NONE;
@@ -676,22 +612,17 @@ void configure_pktio_pmr_match_set_cos(void)
 							 &qparam);
 	CU_ASSERT_FATAL(queue_list[CLS_PMR_SET] != ODP_QUEUE_INVALID);
 
-	retval = odp_cos_queue_set(cos_list[CLS_PMR_SET],
-				   queue_list[CLS_PMR_SET]);
-	CU_ASSERT(retval == 0);
-
-	odp_pool_param_init(&pool_param);
-	pool_param.pkt.seg_len = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.len     = SHM_PKT_BUF_SIZE;
-	pool_param.pkt.num     = SHM_PKT_NUM_BUFS;
-	pool_param.type        = ODP_POOL_PACKET;
 	sprintf(poolname, "cos_pmr_set_pool");
-
-	pool_list[CLS_PMR_SET] = odp_pool_create(poolname, &pool_param);
+	pool_list[CLS_PMR_SET] = pool_create(poolname);
 	CU_ASSERT_FATAL(pool_list[CLS_PMR_SET] != ODP_POOL_INVALID);
-	retval = odp_cls_cos_pool_set(cos_list[CLS_PMR_SET],
-				      pool_list[CLS_PMR_SET]);
-	CU_ASSERT(retval == 0);
+
+	sprintf(cosname, "cos_pmr_set");
+	odp_cls_cos_param_init(&cls_param);
+	cls_param.pool = pool_list[CLS_PMR_SET];
+	cls_param.queue = queue_list[CLS_PMR_SET];
+	cls_param.drop_policy = ODP_COS_DROP_POOL;
+	cos_list[CLS_PMR_SET] = odp_cls_cos_create(cosname, &cls_param);
+	CU_ASSERT_FATAL(cos_list[CLS_PMR_SET] != ODP_COS_INVALID);
 
 	retval = odp_pktio_pmr_match_set_cos(pmr_set, pktio_loop,
 					     cos_list[CLS_PMR_SET]);
diff --git a/test/validation/classification/odp_classification_testsuites.h b/test/validation/classification/odp_classification_testsuites.h
index a09067cd..02828e12 100644
--- a/test/validation/classification/odp_classification_testsuites.h
+++ b/test/validation/classification/odp_classification_testsuites.h
@@ -31,7 +31,8 @@ void configure_default_cos(odp_pktio_t pktio, odp_cos_t *cos,
 int parse_ipv4_string(const char *ipaddress, uint32_t *addr, uint32_t *mask);
 void enqueue_pktio_interface(odp_packet_t pkt, odp_pktio_t pktio);
 odp_packet_t receive_packet(odp_queue_t *queue, uint64_t ns);
-odp_queue_t queue_create(char *queuename, bool sched);
+odp_pool_t pool_create(const char *poolname);
+odp_queue_t queue_create(const char *queuename, bool sched);
 void configure_pktio_default_cos(void);
 void test_pktio_default_cos(void);
 void configure_pktio_error_cos(void);