Patch Detail

HTTP 200 OK
Allow: GET, PUT, PATCH, HEAD, OPTIONS
Content-Type: application/json
Vary: Accept

{
    "id": 139013,
    "url": "https://patches.dpdk.org/api/patches/139013/?format=api",
    "web_url": "https://patches.dpdk.org/project/dpdk/patch/20240401013729.1466298-3-aditya.ambadipudi@arm.com/",
    "project": {
        "id": 1,
        "url": "https://patches.dpdk.org/api/projects/1/?format=api",
        "name": "DPDK",
        "link_name": "dpdk",
        "list_id": "dev.dpdk.org",
        "list_email": "dev@dpdk.org",
        "web_url": "http://core.dpdk.org",
        "scm_url": "git://dpdk.org/dpdk",
        "webscm_url": "http://git.dpdk.org/dpdk",
        "list_archive_url": "https://inbox.dpdk.org/dev",
        "list_archive_url_format": "https://inbox.dpdk.org/dev/{}",
        "commit_url_format": ""
    },
    "msgid": "<20240401013729.1466298-3-aditya.ambadipudi@arm.com>",
    "list_archive_url": "https://inbox.dpdk.org/dev/20240401013729.1466298-3-aditya.ambadipudi@arm.com",
    "date": "2024-04-01T01:37:29",
    "name": "[v1,2/2] deque: add unit tests for the deque library",
    "commit_ref": null,
    "pull_url": null,
    "state": "superseded",
    "archived": false,
    "hash": "bfd0a56cf032c3c0ab42305153bf652f8d693e9d",
    "submitter": {
        "id": 3303,
        "url": "https://patches.dpdk.org/api/people/3303/?format=api",
        "name": "Aditya Ambadipudi",
        "email": "aditya.ambadipudi@arm.com"
    },
    "delegate": {
        "id": 1,
        "url": "https://patches.dpdk.org/api/users/1/?format=api",
        "username": "tmonjalo",
        "first_name": "Thomas",
        "last_name": "Monjalon",
        "email": "thomas@monjalon.net"
    },
    "mbox": "https://patches.dpdk.org/project/dpdk/patch/20240401013729.1466298-3-aditya.ambadipudi@arm.com/mbox/",
    "series": [
        {
            "id": 31651,
            "url": "https://patches.dpdk.org/api/series/31651/?format=api",
            "web_url": "https://patches.dpdk.org/project/dpdk/list/?series=31651",
            "date": "2024-04-01T01:37:27",
            "name": "deque: add multithread unsafe deque library",
            "version": 1,
            "mbox": "https://patches.dpdk.org/series/31651/mbox/"
        }
    ],
    "comments": "https://patches.dpdk.org/api/patches/139013/comments/",
    "check": "fail",
    "checks": "https://patches.dpdk.org/api/patches/139013/checks/",
    "tags": {},
    "related": [],
    "headers": {
        "Return-Path": "<dev-bounces@dpdk.org>",
        "X-Original-To": "patchwork@inbox.dpdk.org",
        "Delivered-To": "patchwork@inbox.dpdk.org",
        "Received": [
            "from mails.dpdk.org (mails.dpdk.org [217.70.189.124])\n\tby inbox.dpdk.org (Postfix) with ESMTP id 8198243D9B;\n\tMon,  1 Apr 2024 03:37:59 +0200 (CEST)",
            "from mails.dpdk.org (localhost [127.0.0.1])\n\tby mails.dpdk.org (Postfix) with ESMTP id 96FBB402E2;\n\tMon,  1 Apr 2024 03:37:45 +0200 (CEST)",
            "from foss.arm.com (foss.arm.com [217.140.110.172])\n by mails.dpdk.org (Postfix) with ESMTP id 3A2FA402D1\n for <dev@dpdk.org>; Mon,  1 Apr 2024 03:37:43 +0200 (CEST)",
            "from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14])\n by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 1B2351474;\n Sun, 31 Mar 2024 18:38:15 -0700 (PDT)",
            "from 2u-thunderx2.usa.Arm.com (unknown [10.118.12.78])\n by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPA id 3D68E3F64C;\n Sun, 31 Mar 2024 18:37:42 -0700 (PDT)"
        ],
        "From": "Aditya Ambadipudi <aditya.ambadipudi@arm.com>",
        "To": "dev@dpdk.org, jackmin@nvidia.com, stephen@networkplumber.org,\n matan@nvidia.com, viacheslavo@nvidia.com, roretzla@linux.microsoft.com,\n konstantin.v.ananyev@yandex.ru, konstantin.ananyev@huawei.com,\n mb@smartsharesystems.com, hofors@lysator.liu.se",
        "Cc": "Honnappa.Nagarahalli@arm.com, Dhruv.Tripathi@arm.com,\n wathsala.vithanage@arm.com, aditya.ambadipudi@arm.com,\n ganeshaditya1@gmail.com, nd@arm.com,\n Honnappa Nagarahalli <Honnappa.nagarahalli@arm.com>",
        "Subject": "[PATCH v1 2/2] deque: add unit tests for the deque library",
        "Date": "Sun, 31 Mar 2024 20:37:29 -0500",
        "Message-Id": "<20240401013729.1466298-3-aditya.ambadipudi@arm.com>",
        "X-Mailer": "git-send-email 2.25.1",
        "In-Reply-To": "<20240401013729.1466298-1-aditya.ambadipudi@arm.com>",
        "References": "<20230821060420.3509667-1-honnappa.nagarahalli@arm.com>\n <20240401013729.1466298-1-aditya.ambadipudi@arm.com>",
        "MIME-Version": "1.0",
        "Content-Transfer-Encoding": "8bit",
        "X-BeenThere": "dev@dpdk.org",
        "X-Mailman-Version": "2.1.29",
        "Precedence": "list",
        "List-Id": "DPDK patches and discussions <dev.dpdk.org>",
        "List-Unsubscribe": "<https://mails.dpdk.org/options/dev>,\n <mailto:dev-request@dpdk.org?subject=unsubscribe>",
        "List-Archive": "<http://mails.dpdk.org/archives/dev/>",
        "List-Post": "<mailto:dev@dpdk.org>",
        "List-Help": "<mailto:dev-request@dpdk.org?subject=help>",
        "List-Subscribe": "<https://mails.dpdk.org/listinfo/dev>,\n <mailto:dev-request@dpdk.org?subject=subscribe>",
        "Errors-To": "dev-bounces@dpdk.org"
    },
    "content": "Add unit test cases that test all of the enqueue/dequeue functions.\nBoth normal enqueue/dequeue functions and the zerocopy API functions.\n\nSigned-off-by: Aditya Ambadipudi <aditya.ambadipudi@arm.com>\nReviewed-by: Honnappa Nagarahalli <Honnappa.nagarahalli@arm.com>\n---\n app/test/meson.build                   |    2 +\n app/test/test_deque_enqueue_dequeue.c  | 1231 ++++++++++++++++++++++++\n app/test/test_deque_helper_functions.c |  170 ++++\n 3 files changed, 1403 insertions(+)\n create mode 100644 app/test/test_deque_enqueue_dequeue.c\n create mode 100644 app/test/test_deque_helper_functions.c",
    "diff": "diff --git a/app/test/meson.build b/app/test/meson.build\nindex 7d909039ae..8913050c9b 100644\n--- a/app/test/meson.build\n+++ b/app/test/meson.build\n@@ -60,6 +60,8 @@ source_file_deps = {\n     'test_cryptodev_security_tls_record.c': ['cryptodev', 'security'],\n     'test_cycles.c': [],\n     'test_debug.c': [],\n+    'test_deque_enqueue_dequeue.c': ['deque'],\n+    'test_deque_helper_functions.c': ['deque'],\n     'test_devargs.c': ['kvargs'],\n     'test_dispatcher.c': ['dispatcher'],\n     'test_distributor.c': ['distributor'],\ndiff --git a/app/test/test_deque_enqueue_dequeue.c b/app/test/test_deque_enqueue_dequeue.c\nnew file mode 100644\nindex 0000000000..35f2dd4451\n--- /dev/null\n+++ b/app/test/test_deque_enqueue_dequeue.c\n@@ -0,0 +1,1231 @@\n+/* SPDX-License-Identifier: BSD-3-Clause\n+ * Copyright(c) 2024 Arm Limited\n+ */\n+\n+\n+#include \"test.h\"\n+\n+#include <assert.h>\n+#include <inttypes.h>\n+#include <signal.h>\n+#include <stdio.h>\n+#include <string.h>\n+#include <unistd.h>\n+\n+#include <rte_common.h>\n+#include <rte_deque.h>\n+#include <rte_errno.h>\n+#include <rte_malloc.h>\n+#include <rte_random.h>\n+\n+struct rte_deque *deque;\n+\n+static const int esize[] = {4, 8, 16, 20};\n+#define DEQUE_SIZE 4096\n+#define MAX_BULK 32\n+#define TEST_DEQUE_FULL_EMPTY_ITER 8\n+\n+/*\n+ * Validate the return value of test cases and print details of the\n+ * deque if validation fails\n+ *\n+ * @param exp\n+ *   Expression to validate return value.\n+ * @param r\n+ *   A pointer to the deque structure.\n+ */\n+#define TEST_DEQUE_VERIFY(exp, d, errst) do {\t\t\t\t\\\n+\tif (!(exp)) {\t\t\t\t\t\t\t\\\n+\t\tprintf(\"error at %s:%d\\tcondition \" #exp \" failed\\n\",\t\\\n+\t\t\t__func__, __LINE__);\t\t\t\t\\\n+\t\trte_deque_dump(stdout, (d));\t\t\t\t\\\n+\t\terrst;\t\t\t\t\t\t\t\\\n+\t}\t\t\t\t\t\t\t\t\\\n+} while (0)\n+\n+static int\n+test_deque_mem_cmp(void *src, void *dst, unsigned int size)\n+{\n+\tint ret;\n+\n+\tret = memcmp(src, dst, size);\n+\tif (ret) {\n+\t\trte_hexdump(stdout, \"src\", src, size);\n+\t\trte_hexdump(stdout, \"dst\", dst, size);\n+\t\tprintf(\"data after dequeue is not the same\\n\");\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static int\n+test_deque_mem_cmp_rvs(void *src, void *dst,\n+\t\tunsigned int count, unsigned int esize)\n+{\n+\tint ret = 0;\n+\tuint32_t *src32 = ((uint32_t *)src), *dst32 = ((uint32_t *)dst);\n+\tuint32_t scale = esize/(sizeof(uint32_t));\n+\n+\t/* Start at the end of the dst and compare from there.*/\n+\tdst32 += (count - 1) * scale;\n+\tfor (unsigned int i = 0; i < count; i++) {\n+\t\tfor (unsigned int j = 0; j < scale; j++) {\n+\t\t\tif (src32[j] != dst32[j]) {\n+\t\t\t\tret = -1;\n+\t\t\t\tbreak;\n+\t\t\t}\n+\t\t}\n+\t\tif (ret)\n+\t\t\tbreak;\n+\t\tdst32 -= scale;\n+\t\tsrc32 += scale;\n+\t}\n+\tif (ret) {\n+\t\trte_hexdump(stdout, \"src\", src, count * esize);\n+\t\trte_hexdump(stdout, \"dst\", dst, count * esize);\n+\t\tprintf(\"data after dequeue is not the same\\n\");\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static inline void *\n+test_deque_calloc(unsigned int dsize, int esize)\n+{\n+\tvoid *p;\n+\n+\tp = rte_zmalloc(NULL, dsize * esize, RTE_CACHE_LINE_SIZE);\n+\tif (p == NULL)\n+\t\tprintf(\"Failed to allocate memory\\n\");\n+\n+\treturn p;\n+}\n+\n+static void\n+test_deque_mem_init(void *obj, unsigned int count, int esize)\n+{\n+\tfor (unsigned int i = 0; i < (count * esize / sizeof(uint32_t)); i++)\n+\t\t((uint32_t *)obj)[i] = i;\n+}\n+\n+static inline void *\n+test_deque_inc_ptr(void *obj, int esize, unsigned int n)\n+{\n+\treturn (void *)((uint32_t *)obj + (n * esize / sizeof(uint32_t)));\n+}\n+\n+/* Copy to the deque memory */\n+static inline void\n+test_deque_zc_copy_to_deque(struct rte_deque_zc_data *zcd, const void *src, int esize,\n+\tunsigned int num)\n+{\n+\tmemcpy(zcd->ptr1, src, esize * zcd->n1);\n+\tif (zcd->n1 != num) {\n+\t\tconst void *inc_src = (const void *)((const char *)src +\n+\t\t\t\t\t\t(zcd->n1 * esize));\n+\t\tmemcpy(zcd->ptr2, inc_src, esize * (num - zcd->n1));\n+\t}\n+}\n+\n+static inline void\n+test_deque_zc_copy_to_deque_rev(struct rte_deque_zc_data *zcd, const void *src,\n+\t\t\t\t\tint esize, unsigned int num)\n+{\n+\tvoid *ptr1 = zcd->ptr1;\n+\tfor (unsigned int i = 0; i < zcd->n1; i++) {\n+\t\tmemcpy(ptr1, src, esize);\n+\t\tsrc = (const void *)((const char *)src + esize);\n+\t\tptr1 = (void *)((char *)ptr1 - esize);\n+\t}\n+\tif (zcd->n1 != num) {\n+\t\tvoid *ptr2 = zcd->ptr2;\n+\t\tfor (unsigned int i = 0; i < (num - zcd->n1); i++) {\n+\t\t\tmemcpy(ptr2, src, esize);\n+\t\t\tsrc = (const void *)((const char *)src + esize);\n+\t\t\tptr2 = (void *)((char *)ptr2 - esize);\n+\t\t}\n+\t}\n+}\n+\n+/* Copy from the deque memory */\n+static inline void\n+test_deque_zc_copy_from_deque(struct rte_deque_zc_data *zcd, void *dst, int esize,\n+\tunsigned int num)\n+{\n+\tmemcpy(dst, zcd->ptr1, esize * zcd->n1);\n+\n+\tif (zcd->n1 != num) {\n+\t\tdst = test_deque_inc_ptr(dst, esize, zcd->n1);\n+\t\tmemcpy(dst, zcd->ptr2, esize * (num - zcd->n1));\n+\t}\n+}\n+\n+static inline void\n+test_deque_zc_copy_from_deque_rev(struct rte_deque_zc_data *zcd, void *dst, int esize,\n+\tunsigned int num)\n+{\n+\tvoid *ptr1 = zcd->ptr1;\n+\tfor (unsigned int i = 0; i < zcd->n1; i++) {\n+\t\tmemcpy(dst, ptr1, esize);\n+\t\tdst = (void *)((char *)dst + esize);\n+\t\tptr1 = (void *)((char *)ptr1 - esize);\n+\t}\n+\tif (zcd->n1 != num) {\n+\t\tvoid *ptr2 = zcd->ptr2;\n+\t\tfor (unsigned int i = 0; i < (num - zcd->n1); i++) {\n+\t\t\tmemcpy(dst, ptr2, esize);\n+\t\t\tdst = (void *)((char *)dst + esize);\n+\t\t\tptr2 = (void *)((char *)ptr2 - esize);\n+\t\t}\n+\t}\n+}\n+\n+/* Wrappers around the zero-copy APIs. The wrappers match\n+ * the normal enqueue/dequeue API declarations.\n+ */\n+static unsigned int\n+test_deque_enqueue_zc_bulk_elem(struct rte_deque *d, const void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *free_space)\n+{\n+\tuint32_t ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_enqueue_zc_bulk_elem_start(d, esize, n,\n+\t\t\t\t\t\t&zcd, free_space);\n+\tif (ret != 0) {\n+\t\t/* Copy the data to the deque */\n+\t\ttest_deque_zc_copy_to_deque(&zcd, obj_table, esize, ret);\n+\t\trte_deque_enqueue_zc_elem_finish(d, ret);\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_dequeue_zc_bulk_elem(struct rte_deque *d, void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *available)\n+{\n+\tunsigned int ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_dequeue_zc_bulk_elem_start(d, esize, n,\n+\t\t\t\t&zcd, available);\n+\tif (ret != 0) {\n+\t\t/* Copy the data from the deque */\n+\t\ttest_deque_zc_copy_from_deque(&zcd, obj_table, esize, ret);\n+\t\trte_deque_dequeue_zc_elem_finish(d, ret);\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_enqueue_zc_burst_elem(struct rte_deque *d, const void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *free_space)\n+{\n+\tuint32_t ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_enqueue_zc_burst_elem_start(d, esize, n,\n+\t\t\t\t\t\t&zcd, free_space);\n+\tif (ret != 0) {\n+\t\t/* Copy the data to the deque */\n+\t\ttest_deque_zc_copy_to_deque(&zcd, obj_table, esize, ret);\n+\t\trte_deque_enqueue_zc_elem_finish(d, ret);\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_dequeue_zc_burst_elem(struct rte_deque *d, void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *available)\n+{\n+\tunsigned int ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_dequeue_zc_burst_elem_start(d, esize, n,\n+\t\t\t\t&zcd, available);\n+\tif (ret != 0) {\n+\t\t/* Copy the data from the deque */\n+\t\ttest_deque_zc_copy_from_deque(&zcd, obj_table, esize, ret);\n+\t\trte_deque_dequeue_zc_elem_finish(d, ret);\n+\t}\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_enqueue_zc_bulk_elem_tail(struct rte_deque *d, const void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *free_space)\n+{\n+\tuint32_t ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_enqueue_zc_bulk_elem_tail_start(d, esize, n,\n+\t\t\t\t\t\t\t&zcd, free_space);\n+\tif (ret != 0) {\n+\t\t/* Copy the data to the deque */\n+\t\ttest_deque_zc_copy_to_deque_rev(&zcd, obj_table, esize, ret);\n+\t\trte_deque_enqueue_zc_elem_tail_finish(d, ret);\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_dequeue_zc_bulk_elem_head(struct rte_deque *d, void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *available)\n+{\n+\tunsigned int ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_dequeue_zc_bulk_elem_head_start(d, esize, n,\n+\t\t\t\t&zcd, available);\n+\tif (ret != 0) {\n+\t\t/* Copy the data from the deque */\n+\t\ttest_deque_zc_copy_from_deque_rev(&zcd, obj_table, esize, ret);\n+\t\trte_deque_dequeue_zc_elem_head_finish(d, ret);\n+\t}\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_enqueue_zc_burst_elem_tail(struct rte_deque *d,\n+\tconst void *obj_table, unsigned int esize, unsigned int n,\n+\tunsigned int *free_space)\n+{\n+\tuint32_t ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_enqueue_zc_burst_elem_tail_start(d, esize, n,\n+\t\t\t\t\t\t\t&zcd, free_space);\n+\tif (ret != 0) {\n+\t\t/* Copy the data to the deque */\n+\t\ttest_deque_zc_copy_to_deque_rev(&zcd, obj_table, esize, ret);\n+\t\trte_deque_enqueue_zc_elem_tail_finish(d, ret);\n+\t}\n+\n+\treturn ret;\n+}\n+\n+static unsigned int\n+test_deque_dequeue_zc_burst_elem_head(struct rte_deque *d, void *obj_table,\n+\tunsigned int esize, unsigned int n, unsigned int *available)\n+{\n+\tunsigned int ret;\n+\tstruct rte_deque_zc_data zcd;\n+\n+\tret = rte_deque_dequeue_zc_burst_elem_head_start(d, esize, n,\n+\t\t\t\t&zcd, available);\n+\tif (ret != 0) {\n+\t\t/* Copy the data from the deque */\n+\t\ttest_deque_zc_copy_from_deque_rev(&zcd, obj_table, esize, ret);\n+\t\trte_deque_dequeue_zc_elem_head_finish(d, ret);\n+\t}\n+\treturn ret;\n+}\n+\n+#define TEST_DEQUE_ELEM_BULK 8\n+#define TEST_DEQUE_ELEM_BURST 16\n+static const struct {\n+\tconst char *desc;\n+\tconst int api_flags;\n+\tunsigned int (*enq)(struct rte_deque *d, const void *obj_table,\n+\t\tunsigned int esize, unsigned int n,\n+\t\tunsigned int *free_space);\n+\tunsigned int (*deq)(struct rte_deque *d, void *obj_table,\n+\t\t\tunsigned int esize, unsigned int n,\n+\t\t\tunsigned int *available);\n+\t/* This dequeues in the opposite direction of enqueue.\n+\t * This is used for testing stack behavior\n+\t */\n+\tunsigned int (*deq_opp)(struct rte_deque *d, void *obj_table,\n+\t\t\tunsigned int esize, unsigned int n,\n+\t\t\tunsigned int *available);\n+} test_enqdeq_impl[] = {\n+\t{\n+\t\t.desc = \"Deque forward direction bulkmode\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BULK,\n+\t\t.enq = rte_deque_enqueue_bulk_elem,\n+\t\t.deq = rte_deque_dequeue_bulk_elem,\n+\t\t.deq_opp = rte_deque_dequeue_at_head_bulk_elem,\n+\t},\n+\t{\n+\t\t.desc = \"Deque forward direction burstmode\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BURST,\n+\t\t.enq = rte_deque_enqueue_burst_elem,\n+\t\t.deq = rte_deque_dequeue_burst_elem,\n+\t\t.deq_opp = rte_deque_dequeue_at_head_burst_elem,\n+\t},\n+\t{\n+\t\t.desc = \"Deque reverse direction bulkmode\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BULK,\n+\t\t.enq = rte_deque_enqueue_at_tail_bulk_elem,\n+\t\t.deq = rte_deque_dequeue_at_head_bulk_elem,\n+\t\t.deq_opp = rte_deque_dequeue_bulk_elem,\n+\t},\n+\t{\n+\t\t.desc = \"Deque reverse direction burstmode\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BURST,\n+\t\t.enq = rte_deque_enqueue_at_tail_burst_elem,\n+\t\t.deq = rte_deque_dequeue_at_head_burst_elem,\n+\t\t.deq_opp = rte_deque_dequeue_burst_elem,\n+\t},\n+\t{\n+\t\t.desc = \"Deque forward direction bulkmode zero copy\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BULK,\n+\t\t.enq = test_deque_enqueue_zc_bulk_elem,\n+\t\t.deq = test_deque_dequeue_zc_bulk_elem,\n+\t\t.deq_opp = test_deque_dequeue_zc_bulk_elem_head,\n+\t},\n+\t{\n+\t\t.desc = \"Deque forward direction burstmode zero copy\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BURST,\n+\t\t.enq = test_deque_enqueue_zc_burst_elem,\n+\t\t.deq = test_deque_dequeue_zc_burst_elem,\n+\t\t.deq_opp = test_deque_dequeue_zc_burst_elem_head,\n+\t},\n+\t{\n+\t\t.desc = \"Deque reverse direction bulkmode zero copy\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BULK,\n+\t\t.enq = test_deque_enqueue_zc_bulk_elem_tail,\n+\t\t.deq = test_deque_dequeue_zc_bulk_elem_head,\n+\t\t.deq_opp = test_deque_dequeue_zc_bulk_elem,\n+\t},\n+\t{\n+\t\t.desc = \"Deque reverse direction burstmode zero copy\",\n+\t\t.api_flags = TEST_DEQUE_ELEM_BURST,\n+\t\t.enq = test_deque_enqueue_zc_burst_elem_tail,\n+\t\t.deq = test_deque_dequeue_zc_burst_elem_head,\n+\t\t.deq_opp = test_deque_dequeue_zc_burst_elem,\n+\t},\n+};\n+\n+/*\n+ * Burst and bulk operations in regular mode and zero copy mode.\n+ * Random number of elements are enqueued and dequeued.\n+ */\n+static int\n+test_deque_burst_bulk_tests1(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tunsigned int ret;\n+\tunsigned int i, j, temp_sz, free_space, available;\n+\tconst unsigned int dsz = DEQUE_SIZE - 1;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Over the boundary deque.\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\tprintf(\"Random full/empty test\\n\");\n+\n+\t\tfor (j = 0; j != TEST_DEQUE_FULL_EMPTY_ITER; j++) {\n+\t\t\t/* random shift in the deque */\n+\t\t\tint rand = RTE_MAX(rte_rand() % DEQUE_SIZE, 1UL);\n+\t\t\tprintf(\"%s: iteration %u, random shift: %u;\\n\",\n+\t\t\t\t__func__, i, rand);\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t\trand, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (unsigned int)rand, d, goto fail);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\t\trand, &available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (unsigned int)rand, d, goto fail);\n+\n+\t\t\t/* fill the deque */\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src,\n+\t\t\t\t\t\t\tesize[i], dsz,\n+\t\t\t\t\t\t\t&free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (int)dsz, d, goto fail);\n+\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_free_count(d) == 0, d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_count(d), d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_full(d), d, goto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d) == 0, d, goto fail);\n+\n+\t\t\t/* empty the deque */\n+\t\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst,\n+\t\t\t\t\t\t\tesize[i], dsz,\n+\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (int)dsz, d, goto fail);\n+\n+\t\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_free_count(d), d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_count(d) == 0, d, goto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_full(d) == 0, d, goto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d), d, goto fail);\n+\n+\t\t\t/* check data */\n+\t\t\ttemp_sz = dsz * esize[i];\n+\t\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp(src, dst, temp_sz) == 0,\n+\t\t\t\t\t\t\td, goto fail);\n+\t\t}\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/*\n+ * Burst and bulk operations with regular & zero copy mode.\n+ * Sequence of simple enqueues/dequeues and validate the enqueued and\n+ * dequeued data.\n+ */\n+static int\n+test_deque_burst_bulk_tests2(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tint ret;\n+\tunsigned int i, free_space, available;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\tesize[i]);\n+\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Multiple enqs, deqs.\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\tprintf(\"enqueue 1 obj\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t1, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 1, d, goto fail);\n+\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 1);\n+\n+\t\tprintf(\"enqueue 2 objs\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t2, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 2);\n+\n+\t\tprintf(\"enqueue MAX_BULK objs\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\tMAX_BULK, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\n+\t\tprintf(\"dequeue 1 obj\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\t1, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == 1, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], 1);\n+\n+\t\tprintf(\"dequeue 2 objs\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\t2, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], 2);\n+\n+\t\tprintf(\"dequeue MAX_BULK objs\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\tMAX_BULK, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], MAX_BULK);\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp(src, dst,\n+\t\t\t\tRTE_PTR_DIFF(cur_dst, dst)) == 0,\n+\t\t\t\td, goto fail);\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/*\n+ * Burst and bulk operations with normal mode & zero copy mode.\n+ * Enqueue and dequeue to cover the entire deque length.\n+ */\n+static int\n+test_deque_burst_bulk_tests3(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tint ret;\n+\tunsigned int i, j, free_space, available;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Full deque length test\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\tprintf(\"fill and empty the deque\\n\");\n+\t\tfor (j = 0; j < DEQUE_SIZE / MAX_BULK; j++) {\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src,\n+\t\t\t\t\t\t\tesize[i], MAX_BULK,\n+\t\t\t\t\t\t\t&free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i],\n+\t\t\t\t\t\t\t\tMAX_BULK);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst,\n+\t\t\t\t\t\t\tesize[i], MAX_BULK,\n+\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i],\n+\t\t\t\t\t\t\t\tMAX_BULK);\n+\t\t}\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp(src, dst,\n+\t\t\t\t\tRTE_PTR_DIFF(cur_dst, dst)) == 0,\n+\t\t\t\t\td, goto fail);\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/*\n+ * Burst and bulk operations with normal mode & zero copy mode.\n+ * Enqueue till the deque is full and dequeue till the deque becomes empty.\n+ */\n+static int\n+test_deque_burst_bulk_tests4(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tint ret;\n+\tunsigned int i, j, available, free_space;\n+\tunsigned int num_elems, api_type;\n+\tapi_type = test_enqdeq_impl[test_idx].api_flags;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Full deque length test\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\tprintf(\"Test enqueue without enough memory space\\n\");\n+\t\tfor (j = 0; j < (DEQUE_SIZE/MAX_BULK - 1); j++) {\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src,\n+\t\t\t\t\t\t\tesize[i], MAX_BULK,\n+\t\t\t\t\t\t\t&free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i],\n+\t\t\t\t\t\t\t\tMAX_BULK);\n+\t\t}\n+\n+\t\tprintf(\"Enqueue 2 objects, free entries = MAX_BULK - 2\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t2, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 2);\n+\n+\t\tprintf(\"Enqueue the remaining entries = MAX_BULK - 3\\n\");\n+\t\t/* Bulk APIs enqueue exact number of elements */\n+\t\tif ((api_type & TEST_DEQUE_ELEM_BULK))\n+\t\t\tnum_elems = MAX_BULK - 3;\n+\t\telse\n+\t\t\tnum_elems = MAX_BULK;\n+\t\t/* Always one free entry left */\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\tnum_elems, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == (MAX_BULK - 3), d, goto fail);\n+\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i],\n+\t\t\t\t\t\t\t(MAX_BULK - 3));\n+\n+\t\tprintf(\"Test if deque is full\\n\");\n+\t\tTEST_DEQUE_VERIFY(rte_deque_full(d) == 1, d, goto fail);\n+\n+\t\tprintf(\"Test enqueue for a full entry\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t1, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 0, d, goto fail);\n+\n+\t\tprintf(\"Test dequeue without enough objects\\n\");\n+\t\tfor (j = 0; j < DEQUE_SIZE / MAX_BULK - 1; j++) {\n+\t\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\t\tMAX_BULK, &available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i],\n+\t\t\t\t\t\tMAX_BULK);\n+\t\t}\n+\n+\t\t/* Available memory space for the exact MAX_BULK entries */\n+\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\t2, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], 2);\n+\n+\t\t/* Bulk APIs enqueue exact number of elements */\n+\t\tif ((api_type & TEST_DEQUE_ELEM_BULK))\n+\t\t\tnum_elems = MAX_BULK - 3;\n+\t\telse\n+\t\t\tnum_elems = MAX_BULK;\n+\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst, esize[i],\n+\t\t\t\t\t\tnum_elems, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK - 3, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], MAX_BULK - 3);\n+\n+\t\tprintf(\"Test if deque is empty\\n\");\n+\t\t/* Check if deque is empty */\n+\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d) == 1, d, goto fail);\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp(src, dst,\n+\t\t\t\t\tRTE_PTR_DIFF(cur_dst, dst)) == 0,\n+\t\t\t\t\td, goto fail);\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/*\n+ * Basic test cases with exact size deque.\n+ */\n+static int\n+test_deque_with_exact_size(void)\n+{\n+\tstruct rte_deque *std_d = NULL, *exact_sz_d = NULL;\n+\tvoid *src_orig = NULL, *dst_orig = NULL;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tconst unsigned int deque_sz = 16;\n+\tunsigned int i, j, free_space, available;\n+\tint ret = -1;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"\\nTest exact size deque. Esize: %d\\n\", esize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"std sized deque\";\n+\t\tstd_d = rte_deque_create(DEQUE_NAME, esize[i], deque_sz, 0, 0);\n+\n+\t\tif (std_d == NULL) {\n+\t\t\tprintf(\"%s: error, can't create std deque\\n\", __func__);\n+\t\t\tgoto test_fail;\n+\t\t}\n+\t\tstatic const char *DEQUE_NAME2 = \"Exact sized deque\";\n+\t\texact_sz_d = rte_deque_create(DEQUE_NAME2, esize[i], deque_sz,\n+\t\t\t\t\t0, RTE_DEQUE_F_EXACT_SZ);\n+\t\tif (exact_sz_d == NULL) {\n+\t\t\tprintf(\"%s: error, can't create exact size deque\\n\",\n+\t\t\t\t\t__func__);\n+\t\t\tgoto test_fail;\n+\t\t}\n+\n+\t\t/* alloc object pointers. Allocate one extra object\n+\t\t * and create an unaligned address.\n+\t\t */\n+\t\tsrc_orig = test_deque_calloc(17, esize[i]);\n+\t\tif (src_orig == NULL)\n+\t\t\tgoto test_fail;\n+\t\ttest_deque_mem_init(src_orig, 17, esize[i]);\n+\t\tsrc = (void *)((uintptr_t)src_orig + 1);\n+\t\tcur_src = src;\n+\n+\t\tdst_orig = test_deque_calloc(17, esize[i]);\n+\t\tif (dst_orig == NULL)\n+\t\t\tgoto test_fail;\n+\t\tdst = (void *)((uintptr_t)dst_orig + 1);\n+\t\tcur_dst = dst;\n+\n+\t\t/*\n+\t\t * Check that the exact size deque is bigger than the\n+\t\t * standard deque\n+\t\t */\n+\t\tTEST_DEQUE_VERIFY(rte_deque_get_size(std_d) <=\n+\t\t\t\trte_deque_get_size(exact_sz_d),\n+\t\t\t\tstd_d, goto test_fail);\n+\n+\t\t/*\n+\t\t * check that the exact_sz_deque can hold one more element\n+\t\t * than the standard deque. (16 vs 15 elements)\n+\t\t */\n+\t\tfor (j = 0; j < deque_sz - 1; j++) {\n+\t\t\tret = test_enqdeq_impl[0].enq(std_d, cur_src, esize[i],\n+\t\t\t\t\t\t1, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 1, std_d, goto test_fail);\n+\t\t\tret = test_enqdeq_impl[0].enq(exact_sz_d, cur_src,\n+\t\t\t\t\t\tesize[i], 1, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 1, exact_sz_d, goto test_fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 1);\n+\t\t}\n+\t\tret = test_enqdeq_impl[0].enq(std_d, cur_src, esize[i], 1,\n+\t\t\t\t\t&free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 0, std_d, goto test_fail);\n+\t\tret = test_enqdeq_impl[0].enq(exact_sz_d, cur_src, esize[i], 1,\n+\t\t\t\t\t&free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == 1, exact_sz_d, goto test_fail);\n+\n+\t\t/* check that dequeue returns the expected number of elements */\n+\t\tret = test_enqdeq_impl[0].deq(exact_sz_d, cur_dst, esize[i],\n+\t\t\t\t\tdeque_sz, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == (int)deque_sz, exact_sz_d,\n+\t\t\t\tgoto test_fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], deque_sz);\n+\n+\t\t/* check that the capacity function returns expected value */\n+\t\tTEST_DEQUE_VERIFY(rte_deque_get_capacity(exact_sz_d) == deque_sz,\n+\t\t\t\texact_sz_d, goto test_fail);\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp(src, dst,\n+\t\t\t\t\tRTE_PTR_DIFF(cur_dst, dst)) == 0,\n+\t\t\t\t\texact_sz_d, goto test_fail);\n+\n+\t\trte_free(src_orig);\n+\t\trte_free(dst_orig);\n+\t\trte_deque_free(std_d);\n+\t\trte_deque_free(exact_sz_d);\n+\t\tsrc_orig = NULL;\n+\t\tdst_orig = NULL;\n+\t\tstd_d = NULL;\n+\t\texact_sz_d = NULL;\n+\t}\n+\n+\treturn 0;\n+\n+test_fail:\n+\trte_free(src_orig);\n+\trte_free(dst_orig);\n+\trte_deque_free(std_d);\n+\trte_deque_free(exact_sz_d);\n+\treturn -1;\n+}\n+\n+/*\n+ * Burst and bulk operations in regular mode and zero copy mode.\n+ * Random number of elements are enqueued and dequeued first.\n+ * Which would bring both head and tail to somewhere in the middle of\n+ * the deque. From that point, stack behavior of the deque is tested.\n+ */\n+static int\n+test_deque_stack_random_tests1(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tunsigned int ret;\n+\tunsigned int i, j, free_space, available;\n+\tconst unsigned int dsz = DEQUE_SIZE - 1;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"Stackmode tests1.\\n\");\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Over the boundary deque.\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\tprintf(\"Random starting point stack test\\n\");\n+\n+\t\tfor (j = 0; j != TEST_DEQUE_FULL_EMPTY_ITER; j++) {\n+\t\t\t/* random shift in the deque */\n+\t\t\tint rand = RTE_MAX(rte_rand() % DEQUE_SIZE, 1UL);\n+\t\t\tprintf(\"%s: iteration %u, random shift: %u;\\n\",\n+\t\t\t\t__func__, i, rand);\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src,\n+\t\t\t\t\t\t\tesize[i], rand,\n+\t\t\t\t\t\t\t&free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret != 0, d, goto fail);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].deq(d, cur_dst,\n+\t\t\t\t\t\t\tesize[i], rand,\n+\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (unsigned int)rand, d,\n+\t\t\t\t\tgoto fail);\n+\n+\t\t\t/* fill the deque */\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t\tdsz, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret != 0, d, goto fail);\n+\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_free_count(d) == 0, d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_count(d), d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_full(d), d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d) == 0, d,\n+\t\t\t\t\tgoto fail);\n+\n+\t\t\t/* empty the deque */\n+\t\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst,\n+\t\t\t\t\t\t\t\tesize[i], dsz,\n+\t\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == (int)dsz, d, goto fail);\n+\n+\t\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_free_count(d), d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_count(d) == 0, d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_full(d) == 0, d,\n+\t\t\t\t\tgoto fail);\n+\t\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d), d, goto fail);\n+\n+\t\t\t/* check data */\n+\t\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp_rvs(src, dst,\n+\t\t\t\t\tdsz, esize[i]) == 0, d, goto fail);\n+\t\t}\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/* Tests both standard mode and zero-copy mode.\n+ * Keep enqueuing 1, 2, MAX_BULK elements till the deque is full.\n+ * Then deque them all and make sure the data is opposite of what\n+ * was enqued.\n+ */\n+static int\n+test_deque_stack_random_tests2(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tunsigned int ret;\n+\tunsigned int i, free_space, available;\n+\tconst unsigned int dsz = DEQUE_SIZE - 1;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"Stackmode tests2.\\n\");\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Multiple enqs, deqs.\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\n+\t\tprintf(\"Enqueue objs till the deque is full.\\n\");\n+\t\tunsigned int count = 0;\n+\t\tconst unsigned int perIterCount = 1 + 2 + MAX_BULK;\n+\t\twhile (count + perIterCount < DEQUE_SIZE - 1) {\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t\t1, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 1, d, goto fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 1);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t\t2, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], 2);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\t\tMAX_BULK, &free_space);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], MAX_BULK);\n+\t\t\tcount += perIterCount;\n+\t\t}\n+\t\tunsigned int leftOver = DEQUE_SIZE - 1 - count;\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\tleftOver, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == leftOver, d, goto fail);\n+\t\tcur_src = test_deque_inc_ptr(cur_src, esize[i], leftOver);\n+\n+\t\tprintf(\"Deque all the enqued objs.\\n\");\n+\t\tcount = 0;\n+\t\twhile (count + perIterCount < DEQUE_SIZE - 1) {\n+\t\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst,\n+\t\t\t\t\t\t\tesize[i], 1, &available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 1, d, goto fail);\n+\t\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], 1);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst,\n+\t\t\t\t\t\t\t\tesize[i], 2,\n+\t\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == 2, d, goto fail);\n+\t\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], 2);\n+\n+\t\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst,\n+\t\t\t\t\t\t\t\tesize[i],\n+\t\t\t\t\t\t\t\tMAX_BULK,\n+\t\t\t\t\t\t\t\t&available);\n+\t\t\tTEST_DEQUE_VERIFY(ret == MAX_BULK, d, goto fail);\n+\t\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], MAX_BULK);\n+\t\t\tcount += perIterCount;\n+\t\t}\n+\t\tleftOver = DEQUE_SIZE - 1 - count;\n+\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst, esize[i],\n+\t\t\t\t\t\t\tleftOver, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == leftOver, d, goto fail);\n+\t\tcur_dst = test_deque_inc_ptr(cur_dst, esize[i], leftOver);\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp_rvs(src, dst,\n+\t\t\t\t\t\tdsz, esize[i]) == 0, d,\n+\t\t\t\t\t\tgoto fail);\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+/*\n+ * Tests both normal mode and zero-copy mode.\n+ * Fill up the whole deque, and drain the deque.\n+ * Make sure the data matches in reverse order.\n+ */\n+static int\n+test_deque_stack_random_tests3(unsigned int test_idx)\n+{\n+\tstruct rte_deque *d;\n+\tvoid *src = NULL, *cur_src = NULL, *dst = NULL, *cur_dst = NULL;\n+\tint ret;\n+\tunsigned int i, available, free_space;\n+\tconst unsigned int dsz = DEQUE_SIZE - 1;\n+\n+\tfor (i = 0; i < RTE_DIM(esize); i++) {\n+\t\tprintf(\"Stackmode tests3.\\n\");\n+\t\tprintf(\"\\n%s, esize: %d\\n\", test_enqdeq_impl[test_idx].desc,\n+\t\t\tesize[i]);\n+\n+\t\t/* Create the deque */\n+\t\tstatic const char *DEQUE_NAME = \"Full deque length test\";\n+\t\td = rte_deque_create(DEQUE_NAME, esize[i], DEQUE_SIZE, 0, 0);\n+\n+\t\t/* alloc dummy object pointers */\n+\t\tsrc = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (src == NULL)\n+\t\t\tgoto fail;\n+\t\ttest_deque_mem_init(src, DEQUE_SIZE * 2, esize[i]);\n+\t\tcur_src = src;\n+\n+\t\t/* alloc some room for copied objects */\n+\t\tdst = test_deque_calloc(DEQUE_SIZE * 2, esize[i]);\n+\t\tif (dst == NULL)\n+\t\t\tgoto fail;\n+\t\tcur_dst = dst;\n+\n+\t\t/* fill the deque */\n+\t\tprintf(\"Fill the whole deque using 1 \"\n+\t\t\"single enqueue operation.\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].enq(d, cur_src, esize[i],\n+\t\t\t\t\t\tdsz, &free_space);\n+\t\tTEST_DEQUE_VERIFY(ret == (int)dsz, d, goto fail);\n+\n+\t\tTEST_DEQUE_VERIFY(rte_deque_free_count(d) == 0, d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_count(d), d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(rte_deque_full(d), d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d) == 0, d, goto fail);\n+\n+\t\t/* empty the deque */\n+\t\tprintf(\"Empty the whole deque.\\n\");\n+\t\tret = test_enqdeq_impl[test_idx].deq_opp(d, cur_dst, esize[i],\n+\t\t\t\t\t\t\tdsz, &available);\n+\t\tTEST_DEQUE_VERIFY(ret == (int)dsz, d, goto fail);\n+\n+\t\tTEST_DEQUE_VERIFY(dsz == rte_deque_free_count(d), d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(rte_deque_count(d) == 0, d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(rte_deque_full(d) == 0, d, goto fail);\n+\t\tTEST_DEQUE_VERIFY(rte_deque_empty(d), d, goto fail);\n+\n+\t\t/* check data */\n+\t\tTEST_DEQUE_VERIFY(test_deque_mem_cmp_rvs(src, dst,\n+\t\t\t\t\tdsz, esize[i]) == 0, d, goto fail);\n+\n+\t\t/* Free memory before test completed */\n+\t\trte_deque_free(d);\n+\t\trte_free(src);\n+\t\trte_free(dst);\n+\t\td = NULL;\n+\t\tsrc = NULL;\n+\t\tdst = NULL;\n+\t}\n+\n+\treturn 0;\n+fail:\n+\trte_deque_free(d);\n+\trte_free(src);\n+\trte_free(dst);\n+\treturn -1;\n+}\n+\n+static int\n+deque_enqueue_dequeue_autotest_fn(void)\n+{\n+\tif (test_deque_with_exact_size() != 0)\n+\t\tgoto fail;\n+\tint (*test_fns[])(unsigned int test_fn_idx) = {\n+\t\ttest_deque_burst_bulk_tests1,\n+\t\ttest_deque_burst_bulk_tests2,\n+\t\ttest_deque_burst_bulk_tests3,\n+\t\ttest_deque_burst_bulk_tests4,\n+\t\ttest_deque_stack_random_tests1,\n+\t\ttest_deque_stack_random_tests2,\n+\t\ttest_deque_stack_random_tests3\n+\t};\n+\tfor (unsigned int test_impl_idx = 0;\n+\t\ttest_impl_idx < RTE_DIM(test_enqdeq_impl); test_impl_idx++) {\n+\t\tfor (unsigned int test_fn_idx = 0;\n+\t\t\ttest_fn_idx < RTE_DIM(test_fns); test_fn_idx++) {\n+\t\t\tif (test_fns[test_fn_idx](test_impl_idx) != 0)\n+\t\t\t\tgoto fail;\n+\t\t}\n+\t}\n+\treturn 0;\n+fail:\n+\t\treturn -1;\n+}\n+\n+REGISTER_FAST_TEST(deque_enqueue_dequeue_autotest, true, true,\n+\t\tdeque_enqueue_dequeue_autotest_fn);\ndiff --git a/app/test/test_deque_helper_functions.c b/app/test/test_deque_helper_functions.c\nnew file mode 100644\nindex 0000000000..78f3185c1b\n--- /dev/null\n+++ b/app/test/test_deque_helper_functions.c\n@@ -0,0 +1,170 @@\n+/* SPDX-License-Identifier: BSD-3-Clause\n+ * Copyright(c) 2024 Arm Limited\n+ */\n+\n+#include \"test.h\"\n+\n+#include <assert.h>\n+#include <inttypes.h>\n+#include <signal.h>\n+#include <stdio.h>\n+#include <string.h>\n+#include <unistd.h>\n+\n+#include <rte_common.h>\n+#include <rte_deque.h>\n+#include <rte_errno.h>\n+#include <rte_malloc.h>\n+#include <rte_tailq.h>\n+\n+static int\n+test_deque_get_memsize(void)\n+{\n+\tconst ssize_t RTE_DEQUE_SZ = sizeof(struct rte_deque);\n+\t/* (1) Should return EINVAL when the supplied size of deque is not a\n+\t * power of 2.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_get_memsize_elem(4, 9), -EINVAL,\n+\t\t\t\t\t  \"Get memsize function failed.\");\n+\n+\t/* (2) Should return EINVAL when the supplied size of deque is not a\n+\t * multiple of 4.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_get_memsize_elem(5, 8), -EINVAL,\n+\t\t\t\t\t  \"Get memsize function failed.\");\n+\n+\t/* (3) Requested size of the deque should be less than or equal to\n+\t * RTE_DEQUEUE_SZ_MASK\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_get_memsize_elem(4, RTE_DEQUE_SZ_MASK), -EINVAL,\n+\t\t\t\t\t  \"Get memsize function failed.\");\n+\n+\t/* (4) A deque of count 1, where the element size is 0, should not allocate\n+\t * any more memory than necessary to hold the dequeu structure.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_get_memsize_elem(0, 1), RTE_DEQUE_SZ,\n+\t\t\t\t\t  \"Get memsize function failed.\");\n+\n+\t/* (5) Make sure the function is calculating the size correctly.\n+\t * size of deque: 128. Size for two elements each of size esize: 8\n+\t * total: 128 + 8 = 132\n+\t * Cache align'd size = 192.\n+\t */\n+\tconst ssize_t calculated_sz = RTE_ALIGN(RTE_DEQUE_SZ + 8, RTE_CACHE_LINE_SIZE);\n+\tTEST_ASSERT_EQUAL(rte_deque_get_memsize_elem(4, 2), calculated_sz,\n+\t\t\t\t\t  \"Get memsize function failed.\");\n+\treturn 0;\n+}\n+\n+/* Define a Test macro that will allow us to correctly free all the rte_deque\n+ * objects that were created as a part of the test in case of a failure.\n+ */\n+\n+#define TEST_DEQUE_MEMSAFE(exp, msg, stmt) do { \\\n+\tif (!(exp)) { \\\n+\t\tprintf(\"error at %s:%d\\tcondition \" #exp \" failed. Msg: %s\\n\",\t\\\n+\t\t\t__func__, __LINE__, msg); \\\n+\t\tstmt; \\\n+\t } \\\n+} while (0)\n+\n+static int\n+test_deque_init(void)\n+{\n+\t{\n+\t/* (1) Make sure init fails when the flags are not correctly passed in. */\n+\tstruct rte_deque deque;\n+\n+\t/* Calling init with undefined flags should fail. */\n+\tTEST_ASSERT_EQUAL(rte_deque_init(&deque, \"Deque\", 10, 0x8),\n+\t\t\t\t\t  -EINVAL, \"Init failed.\");\n+\n+\t/* Calling init with a count that is not a power of 2\n+\t * And also not the setting the RTE_DEQUE_F_EXACT_SZ\n+\t * flag should fail.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_init(&deque, \"Deque\", 10, 0),\n+\t\t\t\t\t  -EINVAL, \"Init failed.\");\n+\n+\t/* Calling init with a count that is not a power of 2\n+\t * Should succeed only if the RTE_DEQUE_F_EXACT_SZ flag is set.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_init(&deque, \"Deque\", 10, RTE_DEQUE_F_EXACT_SZ),\n+\t\t\t\t\t  0, \"Init failed.\");\n+\t}\n+\n+\t{\n+\t/* Make sure all the fields are being correctly set when creating a\n+\t * Deque of a size that is not a power of 2.\n+\t */\n+\tstruct rte_deque deque;\n+\tstatic const char NAME[] = \"Deque\";\n+\n+\t/* Calling init with a count that is not a power of 2\n+\t * But with RTE_DEQUE_F_EXACT_SZ should succeed.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_init(&deque, NAME, 10, RTE_DEQUE_F_EXACT_SZ),\n+\t\t\t\t\t  0, \"Init failed.\");\n+\n+\tTEST_ASSERT_BUFFERS_ARE_EQUAL(deque.name, NAME, sizeof(NAME), \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.flags, RTE_DEQUE_F_EXACT_SZ, \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.size, 16, \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.mask, 15, \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.capacity, 10, \"Init failed.\");\n+\t}\n+\n+\t{\n+\t/* Make sure all the fields are being correctly set when creating a\n+\t * Deque of a size that is a power of 2.\n+\t */\n+\tstruct rte_deque deque;\n+\tstatic const char NAME[] = \"Deque\";\n+\n+\t/* Calling init with a count that is not a power of 2\n+\t * But with RTE_DEQUE_F_EXACT_SZ should succeed.\n+\t */\n+\tTEST_ASSERT_EQUAL(rte_deque_init(&deque, NAME, 16, 0), 0, \"Init failed.\");\n+\n+\tTEST_ASSERT_EQUAL(deque.size, 16, \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.mask, 15, \"Init failed.\");\n+\tTEST_ASSERT_EQUAL(deque.capacity, 15, \"Init failed.\");\n+\t}\n+\treturn 0;\n+}\n+\n+static int\n+test_deque_create(void)\n+{\n+\tstruct rte_deque *deque;\n+\tconst char *NAME = \"Deque\";\n+\tdeque = rte_deque_create(NAME, 4, 16, 0, 0);\n+\n+\t/* Make sure the deque creation is successful. */\n+\tTEST_DEQUE_MEMSAFE(deque != NULL, \"Deque creation failed.\", goto fail);\n+\tTEST_DEQUE_MEMSAFE(deque->memzone != NULL, \"Deque creation failed.\", goto fail);\n+\treturn 0;\n+fail:\n+\trte_free(deque);\n+\treturn -1;\n+}\n+\n+#undef TEST_DEQUE_MEMSAFE\n+\n+static struct unit_test_suite deque_helper_functions_testsuite = {\n+\t.suite_name = \"Deque library helper functions test suite\",\n+\t.unit_test_cases = {\n+\t\tTEST_CASE(test_deque_get_memsize),\n+\t\tTEST_CASE(test_deque_init),\n+\t\tTEST_CASE(test_deque_create),\n+\t\tTEST_CASES_END(), /**< NULL terminate unit test array */\n+\t},\n+};\n+\n+static int\n+deque_helper_functions_autotest_fn(void)\n+{\n+\treturn unit_test_suite_runner(&deque_helper_functions_testsuite);\n+}\n+\n+REGISTER_FAST_TEST(deque_helper_functions_autotest, true, true,\n+\t\tdeque_helper_functions_autotest_fn);\n",
    "prefixes": [
        "v1",
        "2/2"
    ]
}