From patchwork Mon Apr 25 20:14:18 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Bill Fischofer X-Patchwork-Id: 66642 Delivered-To: patch@linaro.org Received: by 10.140.93.198 with SMTP id d64csp1238225qge; Mon, 25 Apr 2016 13:19:17 -0700 (PDT) X-Received: by 10.107.145.67 with SMTP id t64mr15342918iod.135.1461615557590; Mon, 25 Apr 2016 13:19:17 -0700 (PDT) Return-Path: Received: from lists.linaro.org (lists.linaro.org. [54.225.227.206]) by mx.google.com with ESMTP id e32si5678114iod.77.2016.04.25.13.19.17; Mon, 25 Apr 2016 13:19:17 -0700 (PDT) Received-SPF: pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) client-ip=54.225.227.206; Authentication-Results: mx.google.com; spf=pass (google.com: domain of lng-odp-bounces@lists.linaro.org designates 54.225.227.206 as permitted sender) smtp.mailfrom=lng-odp-bounces@lists.linaro.org; dmarc=pass (p=NONE dis=NONE) header.from=linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 12881617B1; Mon, 25 Apr 2016 20:19:17 +0000 (UTC) X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on ip-10-142-244-252 X-Spam-Level: X-Spam-Status: No, score=-2.6 required=5.0 tests=BAYES_00, RCVD_IN_DNSWL_LOW, RCVD_IN_MSPIKE_H3, RCVD_IN_MSPIKE_WL, URIBL_BLOCKED autolearn=disabled version=3.4.0 Received: from [127.0.0.1] (localhost [127.0.0.1]) by lists.linaro.org (Postfix) with ESMTP id 1DB66617F6; Mon, 25 Apr 2016 20:15:11 +0000 (UTC) X-Original-To: lng-odp@lists.linaro.org Delivered-To: lng-odp@lists.linaro.org Received: by lists.linaro.org (Postfix, from userid 109) id 2FE47617B1; Mon, 25 Apr 2016 20:14:59 +0000 (UTC) Received: from mail-ob0-f181.google.com (mail-ob0-f181.google.com [209.85.214.181]) by lists.linaro.org (Postfix) with ESMTPS id A70D961789 for ; Mon, 25 Apr 2016 20:14:28 +0000 (UTC) Received: by mail-ob0-f181.google.com with SMTP id j9so87264830obd.3 for ; Mon, 25 Apr 2016 13:14:28 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=TPcrQTkgjnR2+LsfFSrh25/9S4C3SRb5n7b6yrOKdRA=; b=VsA5P6pAUWbYjfXDQ3VVnX0xmVXc21PDR2QnQ6Wr/XCCtsXHs5MqhW+dxMFs9/RYuZ C7VpqQbkNkYSyK4IbgjivC9JQtrKUbjvan1oHBOeyV7mUWFdqHKndA0XjsOo3VPm6CM0 VhgyJ9vhoWdq9MzRSvCKkrvl0abzZi5wes2xiU6t1bDOI+wuXLKyIL1tf+U8SDVK2CpI vRs8cuCewBjcgB7hZEe9AqfegWoSgFGpK4qOng/6S2lq3nhoXpkk0lHc11+E0j+3m1w9 AdeRJ0BzP1/OQ4iGnU2U7AJNOkOxSdNkE+arUFY1MjVABndg2sY8CbJhAaBac4VIHGz3 PT2A== X-Gm-Message-State: AOPr4FVOItMH8cr5m0rXnoUgDhpSSfR1w7qpRn51grSM/hSEeqGlJpEk3SGPG/1GeOzuy+Xjucg= X-Received: by 10.182.104.194 with SMTP id gg2mr15196569obb.5.1461615268111; Mon, 25 Apr 2016 13:14:28 -0700 (PDT) Received: from Ubuntu15.localdomain (cpe-66-68-129-43.austin.res.rr.com. [66.68.129.43]) by smtp.gmail.com with ESMTPSA id b3sm6959158otc.30.2016.04.25.13.14.27 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 25 Apr 2016 13:14:27 -0700 (PDT) From: Bill Fischofer To: lng-odp@lists.linaro.org Date: Mon, 25 Apr 2016 15:14:18 -0500 Message-Id: <1461615258-17929-8-git-send-email-bill.fischofer@linaro.org> X-Mailer: git-send-email 2.5.0 In-Reply-To: <1461615258-17929-1-git-send-email-bill.fischofer@linaro.org> References: <1461615258-17929-1-git-send-email-bill.fischofer@linaro.org> X-Topics: patch Subject: [lng-odp] [API-NEXT PATCHv2 7/7] validation: packet: add validation tests for new packet apis X-BeenThere: lng-odp@lists.linaro.org X-Mailman-Version: 2.1.16 Precedence: list List-Id: "The OpenDataPlane \(ODP\) List" List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , MIME-Version: 1.0 Errors-To: lng-odp-bounces@lists.linaro.org Sender: "lng-odp" Add CUnit validation tests for the following new packet APIs: odp_packet_copy_part() odp_packet_copy_data() odp_packet_move_data() odp_packet_copy_from_pkt() odp_packet_concat() odp_packet_split() odp_packet_align() Signed-off-by: Bill Fischofer --- test/validation/packet/packet.c | 257 +++++++++++++++++++++++++++++++++++++++- test/validation/packet/packet.h | 2 + 2 files changed, 255 insertions(+), 4 deletions(-) diff --git a/test/validation/packet/packet.c b/test/validation/packet/packet.c index 8c8bd9a..083dad7 100644 --- a/test/validation/packet/packet.c +++ b/test/validation/packet/packet.c @@ -46,6 +46,8 @@ int packet_suite_init(void) }; struct udata_struct *udat; uint32_t udat_size; + uint8_t data = 0; + uint32_t i; packet_pool = odp_pool_create("packet_pool", ¶ms); if (packet_pool == ODP_POOL_INVALID) @@ -53,6 +55,11 @@ int packet_suite_init(void) test_packet = odp_packet_alloc(packet_pool, packet_len); + for (i = 0; i < packet_len; i++) { + odp_packet_copy_from_mem(test_packet, i, 1, &data); + data++; + } + /* Try to allocate the largest possible packet to see * if segmentation is supported */ do { @@ -68,6 +75,12 @@ int packet_suite_init(void) segmentation_supported = odp_packet_is_segmented(segmented_test_packet); + data = 0; + for (i = 0; i < segmented_packet_len; i++) { + odp_packet_copy_from_mem(segmented_test_packet, i, 1, &data); + data++; + } + udat = odp_packet_user_area(test_packet); udat_size = odp_packet_user_area_size(test_packet); if (!udat || udat_size != sizeof(struct udata_struct)) @@ -857,23 +870,104 @@ static void _packet_compare_data(odp_packet_t pkt1, odp_packet_t pkt2) } } +static void _packet_compare_offset(odp_packet_t pkt1, uint32_t off1, + odp_packet_t pkt2, uint32_t off2, + uint32_t len) +{ + uint32_t seglen1, seglen2, cmplen; + + if (off1 + len > odp_packet_len(pkt1) || + off2 + len > odp_packet_len(pkt2)) + return; + + while (len > 0) { + void *pkt1map = odp_packet_offset(pkt1, off1, &seglen1, NULL); + void *pkt2map = odp_packet_offset(pkt2, off2, &seglen2, NULL); + + CU_ASSERT_PTR_NOT_NULL_FATAL(pkt1map); + CU_ASSERT_PTR_NOT_NULL_FATAL(pkt2map); + cmplen = seglen1 < seglen2 ? seglen1 : seglen2; + if (len < cmplen) + cmplen = len; + CU_ASSERT(!memcmp(pkt1map, pkt2map, cmplen)); + + off1 += cmplen; + off2 += cmplen; + len -= cmplen; + } +} + void packet_test_copy(void) { - odp_packet_t pkt = test_packet; - odp_packet_t pkt_copy; + odp_packet_t pkt; + odp_packet_t pkt_copy, pkt_part; odp_pool_t pool; + uint32_t i, plen, seg_len, src_offset, dst_offset; + void *pkt_data; - /** @todo: fill original packet with some data */ + pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet)); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + _packet_compare_data(pkt, test_packet); pool = odp_packet_pool(pkt); CU_ASSERT_FATAL(pool != ODP_POOL_INVALID); - pkt_copy = odp_packet_copy(pkt, odp_packet_pool(pkt)); + pkt_copy = odp_packet_copy(pkt, pool); CU_ASSERT_FATAL(pkt_copy != ODP_PACKET_INVALID); + CU_ASSERT(pkt != pkt_copy); + CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt_copy)); CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt_copy)); _packet_compare_inflags(pkt, pkt_copy); _packet_compare_data(pkt, pkt_copy); odp_packet_free(pkt_copy); + + /* Now test copy_part */ + pkt_part = odp_packet_copy_part(pkt, 0, odp_packet_len(pkt) + 1, pool); + CU_ASSERT(pkt_part == ODP_PACKET_INVALID); + pkt_part = odp_packet_copy_part(pkt, odp_packet_len(pkt), 1, pool); + CU_ASSERT(pkt_part == ODP_PACKET_INVALID); + + pkt_part = odp_packet_copy_part(pkt, 0, odp_packet_len(pkt), pool); + CU_ASSERT_FATAL(pkt_part != ODP_PACKET_INVALID); + CU_ASSERT(pkt != pkt_part); + CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt_part)); + CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt_part)); + + _packet_compare_data(pkt, pkt_part); + odp_packet_free(pkt_part); + + plen = odp_packet_len(pkt); + for (i = 0; i < plen / 2; i += 5) { + pkt_part = odp_packet_copy_part(pkt, i, plen / 4, pool); + CU_ASSERT_FATAL(pkt_part != ODP_PACKET_INVALID); + CU_ASSERT(odp_packet_len(pkt_part) == plen / 4); + _packet_compare_offset(pkt_part, 0, pkt, i, plen / 4); + odp_packet_free(pkt_part); + } + + /* Test copy and move apis */ + CU_ASSERT(odp_packet_copy_data(pkt, 0, plen - plen / 8, plen / 8) == 0); + _packet_compare_offset(pkt, 0, pkt, plen - plen / 8, plen / 8); + _packet_compare_offset(pkt, 0, test_packet, plen - plen / 8, plen / 8); + + /* Test segment crossing if we support segments */ + pkt_data = odp_packet_offset(pkt, 0, &seg_len, NULL); + CU_ASSERT(pkt_data != NULL); + + if (seg_len < plen) { + src_offset = seg_len - 15; + dst_offset = seg_len - 5; + } else { + src_offset = seg_len - 40; + dst_offset = seg_len - 25; + } + + pkt_part = odp_packet_copy_part(pkt, src_offset, 20, pool); + CU_ASSERT(odp_packet_move_data(pkt, dst_offset, src_offset, 20) == 0); + _packet_compare_offset(pkt, dst_offset, pkt_part, 0, 20); + + odp_packet_free(pkt_part); + odp_packet_free(pkt); } void packet_test_copydata(void) @@ -905,6 +999,159 @@ void packet_test_copydata(void) CU_ASSERT(correct_memory); free(data_buf); + + pkt = odp_packet_alloc(odp_packet_pool(test_packet), pkt_len / 2); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + CU_ASSERT(odp_packet_copy_from_pkt(pkt, 0, test_packet, 0, + pkt_len) < 0); + CU_ASSERT(odp_packet_copy_from_pkt(pkt, pkt_len, test_packet, 0, + 1) < 0); + + for (i = 0; i < pkt_len / 2; i++) { + CU_ASSERT(odp_packet_copy_from_pkt(pkt, i, test_packet, i, + 1) == 0); + } + + _packet_compare_offset(pkt, 0, test_packet, 0, pkt_len / 2); + odp_packet_free(pkt); + + pkt = odp_packet_alloc(odp_packet_pool(segmented_test_packet), + odp_packet_len(segmented_test_packet) / 2); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + CU_ASSERT(odp_packet_copy_from_pkt(pkt, 0, segmented_test_packet, + odp_packet_len(pkt) / 4, + odp_packet_len(pkt)) == 0); + _packet_compare_offset(pkt, 0, segmented_test_packet, + odp_packet_len(pkt) / 4, + odp_packet_len(pkt)); + odp_packet_free(pkt); +} + +void packet_test_concatsplit(void) +{ + odp_packet_t pkt, pkt2; + uint32_t pkt_len; + odp_packet_t splits[4]; + + pkt = odp_packet_copy(test_packet, odp_packet_pool(test_packet)); + pkt_len = odp_packet_len(test_packet); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + CU_ASSERT(odp_packet_concat(&pkt, pkt) == 0); + CU_ASSERT(odp_packet_len(pkt) == pkt_len * 2); + _packet_compare_offset(pkt, 0, pkt, pkt_len, pkt_len); + + CU_ASSERT(odp_packet_split(&pkt, pkt_len, &pkt2) == 0); + CU_ASSERT(pkt != pkt2); + CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(pkt2)); + CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(pkt2)); + _packet_compare_data(pkt, pkt2); + _packet_compare_data(pkt, test_packet); + + odp_packet_free(pkt); + odp_packet_free(pkt2); + + pkt = odp_packet_copy(segmented_test_packet, + odp_packet_pool(segmented_test_packet)); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + pkt_len = odp_packet_len(pkt); + + _packet_compare_data(pkt, segmented_test_packet); + CU_ASSERT(odp_packet_split(&pkt, pkt_len / 2, &splits[0]) == 0); + CU_ASSERT(pkt != splits[0]); + CU_ASSERT(odp_packet_data(pkt) != odp_packet_data(splits[0])); + CU_ASSERT(odp_packet_len(pkt) == pkt_len / 2); + CU_ASSERT(odp_packet_len(pkt) + odp_packet_len(splits[0]) == pkt_len); + + _packet_compare_offset(pkt, 0, segmented_test_packet, 0, pkt_len / 2); + _packet_compare_offset(splits[0], 0, segmented_test_packet, + pkt_len / 2, odp_packet_len(splits[0])); + + CU_ASSERT(odp_packet_concat(&pkt, splits[0]) == 0); + _packet_compare_offset(pkt, 0, segmented_test_packet, 0, pkt_len / 2); + _packet_compare_offset(pkt, pkt_len / 2, segmented_test_packet, + pkt_len / 2, pkt_len / 2); + _packet_compare_offset(pkt, 0, segmented_test_packet, 0, + pkt_len); + + CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(segmented_test_packet)); + _packet_compare_data(pkt, segmented_test_packet); + + CU_ASSERT(odp_packet_split(&pkt, pkt_len / 2, &splits[0]) == 0); + CU_ASSERT(odp_packet_split(&pkt, pkt_len / 4, &splits[1]) == 0); + CU_ASSERT(odp_packet_split(&pkt, pkt_len / 8, &splits[2]) == 0); + + CU_ASSERT(odp_packet_len(splits[0]) + odp_packet_len(splits[1]) + + odp_packet_len(splits[2]) + odp_packet_len(pkt) == pkt_len); + + CU_ASSERT(odp_packet_concat(&pkt, splits[2]) == 0); + CU_ASSERT(odp_packet_concat(&pkt, splits[1]) == 0); + CU_ASSERT(odp_packet_concat(&pkt, splits[0]) == 0); + + CU_ASSERT(odp_packet_len(pkt) == odp_packet_len(segmented_test_packet)); + _packet_compare_data(pkt, segmented_test_packet); + + odp_packet_free(pkt); +} + +void packet_test_align(void) +{ + odp_packet_t pkt; + uint32_t pkt_len, seg_len, offset, aligned_seglen; + void *pkt_data, *aligned_data; + + pkt = odp_packet_copy_part(segmented_test_packet, 0, + odp_packet_len(segmented_test_packet) / 2, + odp_packet_pool(segmented_test_packet)); + CU_ASSERT_FATAL(pkt != ODP_PACKET_INVALID); + + pkt_len = odp_packet_len(pkt); + seg_len = odp_packet_seg_len(pkt); + + if (odp_packet_is_segmented(pkt)) { + /* Can't address across segment boundaries */ + CU_ASSERT(odp_packet_align(&pkt, 0, pkt_len, 0) < 0); + + offset = seg_len - 5; + pkt_data = odp_packet_offset(pkt, offset, &seg_len, NULL); + + /* Realign for addressability */ + CU_ASSERT(odp_packet_align(&pkt, offset, + seg_len + 2, 0) >= 0); + + /* Alignment doesn't change packet length or contents */ + CU_ASSERT(odp_packet_len(pkt) == pkt_len); + aligned_data = odp_packet_offset(pkt, offset, + &aligned_seglen, NULL); + _packet_compare_offset(pkt, offset, + segmented_test_packet, offset, + aligned_seglen); + + /* Verify requested contiguous addressabilty */ + CU_ASSERT(aligned_seglen >= seg_len + 2); + } + + /* Get a misaligned address */ + pkt_data = odp_packet_offset(pkt, 0, &seg_len, NULL); + offset = seg_len - 5; + pkt_data = odp_packet_offset(pkt, offset, &seg_len, NULL); + if ((uint64_t)pkt_data % 8 == 0) { + offset--; + pkt_data = odp_packet_offset(pkt, offset, &seg_len, NULL); + } + + /* Realign for alignment */ + CU_ASSERT(odp_packet_align(&pkt, offset, 1, 8) >= 0); + aligned_data = odp_packet_offset(pkt, offset, &aligned_seglen, NULL); + + CU_ASSERT(odp_packet_len(pkt) == pkt_len); + _packet_compare_offset(pkt, offset, segmented_test_packet, offset, + aligned_seglen); + CU_ASSERT((uint64_t)aligned_data % 8 == 0); + + odp_packet_free(pkt); } void packet_test_offset(void) @@ -973,6 +1220,8 @@ odp_testinfo_t packet_suite[] = { ODP_TEST_INFO(packet_test_add_rem_data), ODP_TEST_INFO(packet_test_copy), ODP_TEST_INFO(packet_test_copydata), + ODP_TEST_INFO(packet_test_concatsplit), + ODP_TEST_INFO(packet_test_align), ODP_TEST_INFO(packet_test_offset), ODP_TEST_INFO_NULL, }; diff --git a/test/validation/packet/packet.h b/test/validation/packet/packet.h index 23ce424..142502b 100644 --- a/test/validation/packet/packet.h +++ b/test/validation/packet/packet.h @@ -29,6 +29,8 @@ void packet_test_error_flags(void); void packet_test_add_rem_data(void); void packet_test_copy(void); void packet_test_copydata(void); +void packet_test_concatsplit(void); +void packet_test_align(void); void packet_test_offset(void); /* test arrays: */