From patchwork Fri Nov 18 05:45:02 2016 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Jerin Jacob X-Patchwork-Id: 17083 Return-Path: X-Original-To: patchwork@dpdk.org Delivered-To: patchwork@dpdk.org Received: from [92.243.14.124] (localhost [IPv6:::1]) by dpdk.org (Postfix) with ESMTP id F1529591F; Fri, 18 Nov 2016 06:46:35 +0100 (CET) Received: from NAM01-BY2-obe.outbound.protection.outlook.com (mail-by2nam01on0074.outbound.protection.outlook.com [104.47.34.74]) by dpdk.org (Postfix) with ESMTP id C8E845684 for ; Fri, 18 Nov 2016 06:45:48 +0100 (CET) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=CAVIUMNETWORKS.onmicrosoft.com; s=selector1-cavium-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version; bh=tnoDMtyRIAiOKonTVkZd1PzhY4wvXde/DIYfxYPHhAU=; b=Iwd1d4wTNYAwD891PeJwXkBPTQ88XfV86xvV29nH0bCbnvppI4lj9wdSFMr6Xbv08DTz0fAUC2sLYsatptlPyKFwkcSkGJf/wIv47PCKqwIaWwdPjhvhmTkM1kbLQfoapIdwmf+8LWvv+JyHVMmZ0Rn+5p16FrsNH9jnD+NRgUk= Authentication-Results: spf=none (sender IP is ) smtp.mailfrom=Jerin.Jacob@cavium.com; Received: from localhost.net (50.254.132.37) by BY1PR0701MB1724.namprd07.prod.outlook.com (10.162.111.143) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384_P384) id 15.1.693.12; Fri, 18 Nov 2016 05:45:43 +0000 From: Jerin Jacob To: CC: , , , , Jerin Jacob Date: Fri, 18 Nov 2016 11:15:02 +0530 Message-ID: <1479447902-3700-5-git-send-email-jerin.jacob@caviumnetworks.com> X-Mailer: git-send-email 2.5.5 In-Reply-To: <1479447902-3700-1-git-send-email-jerin.jacob@caviumnetworks.com> References: <1479447902-3700-1-git-send-email-jerin.jacob@caviumnetworks.com> MIME-Version: 1.0 X-Originating-IP: [50.254.132.37] X-ClientProxiedBy: CY1PR1101CA0016.namprd11.prod.outlook.com (10.169.17.26) To BY1PR0701MB1724.namprd07.prod.outlook.com (10.162.111.143) X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 2:ZRaeA3MCg72bXXXioHsGkhK45dehlbbmKtK54iAqC1HsOiWCOYchZNwuwEA162RWcqb98S/1kspNLIzGyi+fY6jAMoFIkQG3L1EiQojUTUUYu+qph4OsKONoi71doQUwBSiDk7ty3wtjs06nx5fUaYopH81HiDUbkPqCq13WM80=; 3:4884m0TYu6EeA2C7BvtzTtKU0+R3rzNJ7al6mlmgYoJL3XzYOrZDTfORb/vivn+UGdFFdF8595Cnc6A7/fBTlytTypOHPCZ9o9ScO3HrU7QQCHXyMIgZW3JICr60+kb0a+GGoM9ZeigYppeD1eQSc5bmRwBpEcmebOo9gV4/jQo= X-MS-Office365-Filtering-Correlation-Id: 84694bcb-f8f5-4fa0-85a2-08d40f762345 X-Microsoft-Antispam: UriScan:; BCL:0; PCL:0; RULEID:(22001); SRVR:BY1PR0701MB1724; X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 25:fXWXgwbmIYmNsiTr9B+bzqJrIR/f2pLo7WOzZWnegJ/OSk+0tiWTBGYcwnPFu2gtYJPUARJ41NLAG0ps62Rr0vB9E49PBgwzISTOMhHzThXmUpFi5wcrznVvsm1UacKBi4bbMjncrRbYsarwIUNOHrJ8kQCfT4Bg+xjSZI7mDknB5kUNY2DOZvb5yPJos0fCr7bBdPpjYWV5ivFK79VKotyfJwx0zlvniXKWgpxELziVpb6C+1ffQcpy/HqNowCWdgrKIqicyP7qyTII71rdbCGz8H5pEpgR3scUUaPSzCn12whoZQgP7ixDcWlZEs8ahaYuBAVuzTZz88hCg+4aXE93H7gcwNpk/gODAd3c6VXgBFkrctJU8BjANdA5k79LX0gdLyaSEFn1X+w8rslQbgdyRk8+zx77Hngeinxb0Tgk0As5uetQaY4JrkTEEnDkksdXkpDubOXkKohL2qmD8cTK4DYL3RUnyt+6PIehvg6IqAIDt9p/YpDzh4yy4p9YC5YHPCLT51ana+qZi09iajD0t98+X2u1BH2YC9H0olxFE3RQEnFE8GThp9t9rNPLip9cgdnQVOYulrde1yGWCXR414VhcznYVgMNqCJi9cexbndauV3RvfeqQp8d+9GOXZigU0aVEYtWO2V/6vrZHIks/7OKa/VlSokRH/kZGyfhejT27LOqh6BiN3sQoZCZz7stXiEiZ+F9ZRDLLFpXTO5VfPjLLlf5Xyylm2Wj8ViIaBgm8oKCTUvcrk6sYR4I+KDMzR4Rde+hDv/ZZ/BjQUbNJm3WKuueSsCFOcvlTO4= X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 31:LsH6v2dVi0aUhXTA0+liLv7la+vfwSrwrg6ngFER14EWcZByG7Gl+ygO0Wfvwrd/V/2+BqI8S/956Fy7pvxAD2vcIFqhYtP7lngz3OCfOYpDwkpx9TbnurITSVgqtef/KEfQiPydTtJbKkC2kB8q1Obhsc62WUGtxlD4TNsM5XyIpFs4FB7irChjwhA/LiR5GVbHg1gW3970t7PNrqBSU7o7fTOT8KuGvNLz7rgFbWToDEc5Ex5WzmcT/XrPDiEMdcMsyXHiTmR4yysrOjq7SZRlEG7Emq4XHnok0ScsPzU=; 20:pDJasDiSRTO7oQUqs2qfxPMpHts+YWHH6rHpIFHKZxFik/ymCCWolI2oIViCDXSg1fk1nJ69Qih5yy69kfF3AHRrIqclBw+9YaxeaAc6ROdiSyk/qaXGIe5jLaCd3ixwRihC5+1zNfZvh11/PKH7W2fvcgOvQ97AAw1jcQZ3opMxJOStQcPNzjmL0JW9xv+xwICjek2i/hl5ivY6K6mN9slOjxRCXZZ99xg7hS6FqqVcESHSz97X62jrOzo4CTRxObScIKowgu5vuBR149IIQrSyAhTcaLWmpn7Lb2elLGDuuzhoHzHLHzY6bsRTLOIYq7eAVv/oRuMXn6Cx5bXSgzrkjEC9DD7PmCScR4B77jENK5KnDXS/D023OO/Ti4SoVcOUTxmxsDTB0L433OUj0XZNtJCE7U2ZfdDU/a/ytLUnmmJqfi4fx4eFxftqbfAQcab7/Dvq7G/Un1V4qsi4l0byXBJ2UGW61vXIzmysoJp00ODBQ+Jc+6C9j91ygpoUwPjT1G2w9r1qNJV7kMcoG7nzsBr1t8bHBjFi2ZFyvlYOyWUWyFtnNLmneq/eSLH5QD3Pb5fnarl5ptI5mQZLaC9ElktbjL0Vvi8GWtKyN7s= X-Microsoft-Antispam-PRVS: X-Exchange-Antispam-Report-Test: UriScan:; X-Exchange-Antispam-Report-CFA-Test: BCL:0; PCL:0; RULEID:(6060326)(6040281)(601004)(2401047)(8121501046)(5005006)(10201501046)(3002001)(6061324)(6041223); SRVR:BY1PR0701MB1724; BCL:0; PCL:0; RULEID:; SRVR:BY1PR0701MB1724; X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 4:g6TASWHINTvIa45r1RTrzO0E5SheHyrVw26MZBel102Y8swZ8DQS0Kg1FX3WEQXR5SA2AUS0w6yhPktWLZkJ4N8cu1Yowlp0fBL3P8chQlTABtP9hQa8GYp+paHPT7gxWsh476yVm5KjZYu6pog3Jnsv3GSmNHQ2E/CGxspk1TWh7NAK20XDkxJIpowYGioBKF+YFZkYLQ+k8fvSMWuL+ViOCOH1NZ+2DkfHNxZ+JA3Pb+PGDbl2EtjvAUeWamrTsDX4EUDZKAES7wQ8rJFXlnCnHvuwE0vy+pL053i0f7id991JKXgIZp+giM0BwkfOjx5DdOUqG59gHL/8grVhVL9EBGZaaQmU8ANUKNgBpMqaJ8bByWqcOh7On4KX2jvcyKjm3YuiT+Mnqq+nZVrE8aZOsVVLSvCs849MT9HT/J2tSXRcRDAyqGqo8GRfm9o0Z447qafxrEvr8wlvfKGrXg== X-Forefront-PRVS: 01304918F3 X-Forefront-Antispam-Report: SFV:NSPM; SFS:(10009020)(4630300001)(6069001)(6009001)(7916002)(189002)(199003)(68736007)(66066001)(3846002)(7736002)(50226002)(69596002)(81166006)(47776003)(4326007)(4001430100002)(48376002)(6116002)(8676002)(81156014)(8666005)(42186005)(33026002)(105586002)(2351001)(92566002)(2906002)(7846002)(50466002)(50986999)(110136003)(5660300001)(76176999)(42882006)(33646002)(6916009)(189998001)(21086003)(107886002)(36756003)(305945005)(2950100002)(6666003)(101416001)(97736004)(77096005)(5003940100001)(106356001)(76506005)(7059030); DIR:OUT; SFP:1101; SCL:1; SRVR:BY1PR0701MB1724; H:localhost.net; FPR:; SPF:None; PTR:InfoNoRecords; MX:1; A:1; LANG:en; Received-SPF: None (protection.outlook.com: cavium.com does not designate permitted sender hosts) X-Microsoft-Exchange-Diagnostics: =?us-ascii?Q?1; BY1PR0701MB1724; 23:0b4aSHNRdMVWXOVH1hSTQTJfoYev5jvNhw71F/E?= =?us-ascii?Q?Jl5X/MxapscFjkI1+43SoJh7csMpbsJjwxq2n4CXL+CIE2g36nJ0RTEuP/8E?= =?us-ascii?Q?ShRpqTqJ8Wx3DmEWl4F7DJ0pR6FfpmBkqkxH2ioSWv5aoj9Poe4broOrbVfd?= =?us-ascii?Q?29t+Qpr8/HBHap1D8zu2d1NwWMc/m38ZY573C6yFvpBnmCTG0doGSW6lFvXw?= =?us-ascii?Q?v9SgLKuUg4nAQV7cCXWNLddfnnim2+6gfEyp1ZMUHzk7qZkvlOndrGghVSAW?= =?us-ascii?Q?0Re+NpvSjoX0UGEoAsHBtuQxOJiuitfkNM+B4J4UJPqSmNhDOhrhhQ6FeAB9?= =?us-ascii?Q?Bw1uHQ/WfJpDm8Bd8+F2sZ6pkJOtuxx32vSCEmxvkaT0oGgIKVtDuc7EOYwJ?= =?us-ascii?Q?9buSavl5zhyounxiABgPAokofh0NVXe+b/kXrvX+BBwqh5pkCklWMQzRg/q1?= =?us-ascii?Q?kBfvyvI/ytwbeH7lX3bwbdhgS7vjEHLwRsjCXvp6NIO8Rzqafe3/cXsudw9g?= =?us-ascii?Q?GIY6CzmFDiKLyxyMmppJ9G1KnMYpx4B+KIsgY8RGmW1IbX+uJAKnpsi2Wl8K?= =?us-ascii?Q?X1j6cb2Fd/aZLREpc849tBxvGQFdfXZpTfUhbWLBog1JzUUFsujLDtUx8ldE?= =?us-ascii?Q?VCGUhlY82kY5NOJf6msafRnsJy4vUCb+6LLuDaP256USatU+yUGem3fRSHPo?= =?us-ascii?Q?nrK/6HRlN2NXBmsvhh4JeOtGGQx1AX+5yUTuQ7cYKk37vhnX5XChtdkK4/kn?= =?us-ascii?Q?YvCwTSGzf4j0eM/usVfMReWMNz2SQHwoRGdFGaJuomaLeJH5f8XTJ65xO0eQ?= =?us-ascii?Q?ju/kadC85E0Tf3yMRvUYbomtmFPJCUYPk7P00ZPK2yf/GItzNDLNdzg4U1wa?= =?us-ascii?Q?pbaVJ1Tw2DC0j5+C0Qy9W5DMUVcI0my6YWs/4yb4liAZTNXeVkHVTIO3DLFe?= =?us-ascii?Q?In3DXkQwKSBHSAYh+B/zsCMk0U7g+GI/07QtHyQ3RCR5X8jeRySK1Su8EVwh?= =?us-ascii?Q?9ryB4aieRtnanmQnje/q6jejbwZhrGQwpeWtOTv/qhA9+uYk27XURVnpU/dQ?= =?us-ascii?Q?eL7uu+qVBbocoBLuJznvAoHXij9noTyU0f4mabLcHGZb8kGwvHTK64XBMarv?= =?us-ascii?Q?euCc8bGMJJagRVLYbGY0vn/FA2gcwzw3es8yM1jeoa2J4YS9NdxjBK2lq2R9?= =?us-ascii?Q?P6pAm6G+xgPNM+PAaHXgsWXqOXAmyhvw/zcYm6bqD8C4DWauuIT2ocRVUrw?= =?us-ascii?Q?=3D=3D?= X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 6:Y8XKBDA/EWXnFuftse51nblVfPcGh/X10hFO/d/Qqq8n7/K+W28p0+VngyjX6r1AN3A9VDpqn6R/gGvm9iNKRs7tTEv9vdKGK1lDfVyX76rCDi53O5N5OYocSuC4g+iB+mmDODDrmn+nkrgtvEwn0+LfOImGJTxOfHh0DSln+Qp+9Bo1UdhMMANRoElWvTWKFWpttmJ8IjDpiuWD5ZpR+XJShobHrk/atD/RHXyFCZHQqMb2oQAFdAIcmYmbl2oxONOFZJFc+gxUe/P7fRaJHcgq6NiRXXieyjaZtFGyqRiybqy269Za6X99ysiTkhapOQt3gVOMkzxvYOEM7zrqTwHstYNgY65gEDm82vj80vc=; 5:bDXDbwL6vgYm/BEL6MhRNuHdp6tBj75vN66KxE9rFX2c/BcAy+Dhv/0EvFj119vmlsZYVtDt9yTPvAotvDCZLbYHWXqK/n5ehLlUhW/GJLyITIwzJ6kXci2opNKBmfOyPS4w3vKPw8KF7NLY9ZO9GQ==; 24:bHKXRjTVWbONyHeaorC33xtYoU521VeX2eQ3Rh5jUpqCNyjrhfhb/DAOfPNVRWIPaHjRH96sFw04oXOqk8IwlWtnWI6w+QGdjo2I+Q0ObZc= SpamDiagnosticOutput: 1:99 SpamDiagnosticMetadata: NSPM X-Microsoft-Exchange-Diagnostics: 1; BY1PR0701MB1724; 7:XoePEGBhRoGXIbvlC1IYOkCl+Mku0JHMTmDhPujn2xYzjn6WnkNZoU5IPryhjnSKOI7He4ro6d4amAZha5BClP9W31lCfYM1+Y+yQEefaI4cGwQp702ZXwhdCMDB6Gql63fkr8FvjZUJ1wOwAhmsI3KhEz+BdzNzLaBABLg8NI2pTRvDrYveG9rmDpUu8P+3PAWPbZ971JRw5JkM5uiWPKDClWwv4vbV6L8FHbXzqNjTfQFrG0BX8gMBl1gEma0D33A1useQPpdTdw97BrZ3+v5WtREbRUkVBBUYa97nKR/n2+dM7H4XXrBqE0JqmDyRXRVGHruwv+vqYEJb++y6ZlbuCPX9QpamhQ6kdPvDVp0= X-OriginatorOrg: caviumnetworks.com X-MS-Exchange-CrossTenant-OriginalArrivalTime: 18 Nov 2016 05:45:43.2634 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-Transport-CrossTenantHeadersStamped: BY1PR0701MB1724 Subject: [dpdk-dev] [PATCH 4/4] app/test: unit test case for eventdev APIs X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: patches and discussions about DPDK List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" This commit adds basic unit tests for the eventdev API. commands to run the test app: ./build/app/test -c 2 RTE>>eventdev_common_autotest Signed-off-by: Jerin Jacob --- MAINTAINERS | 1 + app/test/Makefile | 2 + app/test/test_eventdev.c | 776 +++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 779 insertions(+) create mode 100644 app/test/test_eventdev.c diff --git a/MAINTAINERS b/MAINTAINERS index c594a23..887f133 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -252,6 +252,7 @@ F: examples/l2fwd-crypto/ Eventdev API - EXPERIMENTAL M: Jerin Jacob F: lib/librte_eventdev/ +F: app/test/test_eventdev* F: drivers/event/skeleton/ Networking Drivers diff --git a/app/test/Makefile b/app/test/Makefile index 5be023a..e28c079 100644 --- a/app/test/Makefile +++ b/app/test/Makefile @@ -197,6 +197,8 @@ SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_blockcipher.c SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev_perf.c SRCS-$(CONFIG_RTE_LIBRTE_CRYPTODEV) += test_cryptodev.c +SRCS-$(CONFIG_RTE_LIBRTE_EVENTDEV) += test_eventdev.c + SRCS-$(CONFIG_RTE_LIBRTE_KVARGS) += test_kvargs.c CFLAGS += -O3 diff --git a/app/test/test_eventdev.c b/app/test/test_eventdev.c new file mode 100644 index 0000000..e876804 --- /dev/null +++ b/app/test/test_eventdev.c @@ -0,0 +1,776 @@ +/*- + * BSD LICENSE + * + * Copyright(c) 2016 Cavium networks. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in + * the documentation and/or other materials provided with the + * distribution. + * * Neither the name of Cavium networks nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR + * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT + * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "test.h" + +#define TEST_DEV_NAME EVENTDEV_NAME_SKELETON_PMD + +static inline uint8_t +test_dev_id_get(void) +{ + return rte_event_dev_get_dev_id(RTE_STR(TEST_DEV_NAME)"_0"); +} + +static int +testsuite_setup(void) +{ + return rte_eal_vdev_init(RTE_STR(TEST_DEV_NAME), NULL); +} + +static void +testsuite_teardown(void) +{ +} + +static int +test_eventdev_count(void) +{ + uint8_t count; + count = rte_event_dev_count(); + TEST_ASSERT(count > 0, "Invalid eventdev count %" PRIu8, count); + return TEST_SUCCESS; +} + +static int +test_eventdev_get_dev_id(void) +{ + int ret; + ret = rte_event_dev_get_dev_id(RTE_STR(TEST_DEV_NAME)"_0"); + TEST_ASSERT(ret >= 0, "Failed to get dev_id %d", ret); + ret = rte_event_dev_get_dev_id("not_a_valid_ethdev_driver"); + TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d", ret); + return TEST_SUCCESS; +} + +static int +test_eventdev_socket_id(void) +{ + int ret, socket_id; + ret = rte_event_dev_get_dev_id(RTE_STR(TEST_DEV_NAME)"_0"); + socket_id = rte_event_dev_socket_id(ret); + TEST_ASSERT(socket_id != -EINVAL, "Failed to get socket_id %d", + socket_id); + socket_id = rte_event_dev_socket_id(RTE_EVENT_MAX_DEVS); + TEST_ASSERT(socket_id == -EINVAL, "Expected -EINVAL %d", socket_id); + + return TEST_SUCCESS; +} + +static int +test_eventdev_info_get(void) +{ + int ret; + struct rte_event_dev_info info; + ret = rte_event_dev_info_get(test_dev_id_get(), NULL); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + TEST_ASSERT(info.max_event_ports > 0, + "Not enough event ports %d", info.max_event_ports); + TEST_ASSERT(info.max_event_queues > 0, + "Not enough event queues %d", info.max_event_queues); + return TEST_SUCCESS; +} + +static inline void +devconf_set_default_sane_values(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + memset(dev_conf, 0, sizeof(struct rte_event_dev_config)); + dev_conf->dequeue_wait_ns = info->min_dequeue_wait_ns; + dev_conf->nb_event_ports = info->max_event_ports; + dev_conf->nb_event_queues = info->max_event_queues; + dev_conf->nb_event_queue_flows = info->max_event_queue_flows; + dev_conf->nb_event_port_dequeue_depth = + info->max_event_port_dequeue_depth; + dev_conf->nb_event_port_enqueue_depth = + info->max_event_port_enqueue_depth; + dev_conf->nb_event_port_enqueue_depth = + info->max_event_port_enqueue_depth; + dev_conf->nb_events_limit = + info->max_num_events; +} + +static int +test_ethdev_config_run(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info, + void (*fn)(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info)) +{ + devconf_set_default_sane_values(dev_conf, info); + fn(dev_conf, info); + return rte_event_dev_configure(test_dev_id_get(), dev_conf); +} + +static void +min_dequeue_limit(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->dequeue_wait_ns = info->min_dequeue_wait_ns - 1; +} + +static void +max_dequeue_limit(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->dequeue_wait_ns = info->max_dequeue_wait_ns + 1; +} + +static void +max_events_limit(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_events_limit = info->max_num_events + 1; +} + +static void +max_event_ports(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_event_ports = info->max_event_ports + 1; +} + +static void +max_event_queues(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_event_queues = info->max_event_queues + 1; +} + +static void +max_event_queue_flows(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_event_queue_flows = info->max_event_queue_flows + 1; +} + +static void +max_event_port_dequeue_depth(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_event_port_dequeue_depth = + info->max_event_port_dequeue_depth + 1; +} + +static void +max_event_port_enqueue_depth(struct rte_event_dev_config *dev_conf, + struct rte_event_dev_info *info) +{ + dev_conf->nb_event_port_enqueue_depth = + info->max_event_port_enqueue_depth + 1; +} + + +static int +test_eventdev_configure(void) +{ + int ret; + struct rte_event_dev_config dev_conf; + struct rte_event_dev_info info; + ret = rte_event_dev_configure(test_dev_id_get(), NULL); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + /* Check limits */ + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, min_dequeue_limit), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, max_dequeue_limit), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, max_events_limit), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, max_event_ports), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, max_event_queues), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, max_event_queue_flows), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, + max_event_port_dequeue_depth), + "Config negative test failed"); + TEST_ASSERT_EQUAL(-EINVAL, + test_ethdev_config_run(&dev_conf, &info, + max_event_port_enqueue_depth), + "Config negative test failed"); + + /* Positive case */ + devconf_set_default_sane_values(&dev_conf, &info); + ret = rte_event_dev_configure(test_dev_id_get(), &dev_conf); + TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev"); + + /* re-configure */ + devconf_set_default_sane_values(&dev_conf, &info); + dev_conf.nb_event_ports = info.max_event_ports/2; + dev_conf.nb_event_queues = info.max_event_queues/2; + ret = rte_event_dev_configure(test_dev_id_get(), &dev_conf); + TEST_ASSERT_SUCCESS(ret, "Failed to re configure eventdev"); + + /* re-configure back to max_event_queues and max_event_ports */ + devconf_set_default_sane_values(&dev_conf, &info); + ret = rte_event_dev_configure(test_dev_id_get(), &dev_conf); + TEST_ASSERT_SUCCESS(ret, "Failed to re-configure eventdev"); + + return TEST_SUCCESS; + +} + +static int +eventdev_configure_setup(void) +{ + int ret; + struct rte_event_dev_config dev_conf; + struct rte_event_dev_info info; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + devconf_set_default_sane_values(&dev_conf, &info); + ret = rte_event_dev_configure(test_dev_id_get(), &dev_conf); + TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev"); + + return TEST_SUCCESS; +} + +static int +test_eventdev_queue_default_conf_get(void) +{ + int i, ret; + struct rte_event_queue_conf qconf; + + ret = rte_event_queue_default_conf_get(test_dev_id_get(), 0, NULL); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + ret = rte_event_queue_default_conf_get(test_dev_id_get(), i, + &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d info", i); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_queue_setup(void) +{ + int i, ret; + struct rte_event_dev_info info; + struct rte_event_queue_conf qconf; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + /* Negative cases */ + ret = rte_event_queue_default_conf_get(test_dev_id_get(), 0, &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info"); + qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ALL_TYPES & + RTE_EVENT_QUEUE_CFG_TYPE_MASK); + qconf.nb_atomic_flows = info.max_event_queue_flows + 1; + ret = rte_event_queue_setup(test_dev_id_get(), 0, &qconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + qconf.nb_atomic_flows = info.max_event_queue_flows; + qconf.event_queue_cfg = (RTE_EVENT_QUEUE_CFG_ATOMIC_ONLY & + RTE_EVENT_QUEUE_CFG_TYPE_MASK); + qconf.nb_atomic_order_sequences = info.max_event_queue_flows + 1; + ret = rte_event_queue_setup(test_dev_id_get(), 0, &qconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + ret = rte_event_queue_setup(test_dev_id_get(), info.max_event_queues, + &qconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + /* Positive case */ + ret = rte_event_queue_default_conf_get(test_dev_id_get(), 0, &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get queue0 info"); + ret = rte_event_queue_setup(test_dev_id_get(), 0, &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to setup queue0"); + + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + ret = rte_event_queue_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_queue_count(void) +{ + int ret; + struct rte_event_dev_info info; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + TEST_ASSERT_EQUAL(rte_event_queue_count(test_dev_id_get()), + info.max_event_queues, "Wrong queue count"); + + return TEST_SUCCESS; +} + +static int +test_eventdev_queue_priority(void) +{ + int i, ret; + struct rte_event_dev_info info; + struct rte_event_queue_conf qconf; + uint8_t priority; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + ret = rte_event_queue_default_conf_get(test_dev_id_get(), i, + &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get queue%d def conf", i); + qconf.priority = i % RTE_EVENT_QUEUE_PRIORITY_LOWEST; + ret = rte_event_queue_setup(test_dev_id_get(), i, &qconf); + TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i); + } + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + priority = rte_event_queue_priority(test_dev_id_get(), i); + if (info.event_dev_cap & RTE_EVENT_DEV_CAP_QUEUE_QOS) + TEST_ASSERT_EQUAL(priority, + i % RTE_EVENT_QUEUE_PRIORITY_LOWEST, + "Wrong priority value for queue%d", i); + else + TEST_ASSERT_EQUAL(priority, + RTE_EVENT_QUEUE_PRIORITY_NORMAL, + "Wrong priority value for queue%d", i); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_port_default_conf_get(void) +{ + int i, ret; + struct rte_event_port_conf pconf; + + ret = rte_event_port_default_conf_get(test_dev_id_get(), 0, NULL); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + ret = rte_event_port_default_conf_get(test_dev_id_get(), + rte_event_port_count(test_dev_id_get()) + 1, NULL); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + for (i = 0; i < rte_event_port_count(test_dev_id_get()); i++) { + ret = rte_event_port_default_conf_get(test_dev_id_get(), i, + &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get port%d info", i); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_port_setup(void) +{ + int i, ret; + struct rte_event_dev_info info; + struct rte_event_port_conf pconf; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + /* Negative cases */ + ret = rte_event_port_default_conf_get(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info"); + pconf.new_event_threshold = info.max_num_events + 1; + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + pconf.new_event_threshold = info.max_num_events; + pconf.dequeue_depth = info.max_event_port_dequeue_depth + 1; + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + pconf.dequeue_depth = info.max_event_port_dequeue_depth; + pconf.enqueue_depth = info.max_event_port_enqueue_depth + 1; + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + ret = rte_event_port_setup(test_dev_id_get(), info.max_event_ports, + &pconf); + TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret); + + /* Positive case */ + ret = rte_event_port_default_conf_get(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info"); + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port0"); + + + for (i = 0; i < rte_event_port_count(test_dev_id_get()); i++) { + ret = rte_event_port_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_dequeue_depth(void) +{ + int ret; + struct rte_event_dev_info info; + struct rte_event_port_conf pconf; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + ret = rte_event_port_default_conf_get(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info"); + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port0"); + + TEST_ASSERT_EQUAL(rte_event_port_dequeue_depth(test_dev_id_get(), 0), + pconf.dequeue_depth, "Wrong port dequeue depth"); + + return TEST_SUCCESS; +} + +static int +test_eventdev_enqueue_depth(void) +{ + int ret; + struct rte_event_dev_info info; + struct rte_event_port_conf pconf; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + ret = rte_event_port_default_conf_get(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to get port0 info"); + ret = rte_event_port_setup(test_dev_id_get(), 0, &pconf); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port0"); + + TEST_ASSERT_EQUAL(rte_event_port_enqueue_depth(test_dev_id_get(), 0), + pconf.enqueue_depth, "Wrong port enqueue depth"); + + return TEST_SUCCESS; +} + +static int +test_eventdev_port_count(void) +{ + int ret; + struct rte_event_dev_info info; + + ret = rte_event_dev_info_get(test_dev_id_get(), &info); + TEST_ASSERT_SUCCESS(ret, "Failed to get event dev info"); + + TEST_ASSERT_EQUAL(rte_event_port_count(test_dev_id_get()), + info.max_event_ports, "Wrong port count"); + + return TEST_SUCCESS; +} + +static int +test_eventdev_wait_time(void) +{ + int ret; + uint64_t wait_ticks; + + ret = rte_event_dequeue_wait_time(test_dev_id_get(), 100, &wait_ticks); + TEST_ASSERT_SUCCESS(ret, "Fail to get wait_time"); + + return TEST_SUCCESS; +} + + +static int +test_eventdev_start_stop(void) +{ + int i, ret; + + ret = eventdev_configure_setup(); + TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev"); + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + ret = rte_event_queue_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i); + } + + for (i = 0; i < rte_event_port_count(test_dev_id_get()); i++) { + ret = rte_event_port_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i); + } + + ret = rte_event_dev_start(test_dev_id_get()); + TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", test_dev_id_get()); + + rte_event_dev_stop(test_dev_id_get()); + return TEST_SUCCESS; +} + + +static int +eventdev_setup_device(void) +{ + int i, ret; + + ret = eventdev_configure_setup(); + TEST_ASSERT_SUCCESS(ret, "Failed to configure eventdev"); + + for (i = 0; i < rte_event_queue_count(test_dev_id_get()); i++) { + ret = rte_event_queue_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup queue%d", i); + } + + for (i = 0; i < rte_event_port_count(test_dev_id_get()); i++) { + ret = rte_event_port_setup(test_dev_id_get(), i, NULL); + TEST_ASSERT_SUCCESS(ret, "Failed to setup port%d", i); + } + + ret = rte_event_dev_start(test_dev_id_get()); + TEST_ASSERT_SUCCESS(ret, "Failed to start device%d", test_dev_id_get()); + + return TEST_SUCCESS; +} + +static void +eventdev_stop_device(void) +{ + rte_event_dev_stop(test_dev_id_get()); +} + +static int +test_eventdev_link(void) +{ + int ret, nb_queues, i; + struct rte_event_queue_link links[RTE_EVENT_MAX_QUEUES_PER_DEV]; + + ret = rte_event_port_link(test_dev_id_get(), 0, NULL, 0); + TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d", + test_dev_id_get()); + + nb_queues = rte_event_queue_count(test_dev_id_get()); + for (i = 0; i < nb_queues; i++) { + links[i].queue_id = i; + links[i].priority = RTE_EVENT_QUEUE_SERVICE_PRIORITY_NORMAL; + } + + ret = rte_event_port_link(test_dev_id_get(), 0, links, nb_queues); + TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d", + test_dev_id_get(), ret); + return TEST_SUCCESS; +} + +static int +test_eventdev_unlink(void) +{ + int ret, nb_queues, i; + uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV]; + + ret = rte_event_port_unlink(test_dev_id_get(), 0, NULL, 0); + TEST_ASSERT(ret >= 0, "Failed to unlink with NULL device%d", + test_dev_id_get()); + + nb_queues = rte_event_queue_count(test_dev_id_get()); + for (i = 0; i < nb_queues; i++) + queues[i] = i; + + + ret = rte_event_port_unlink(test_dev_id_get(), 0, queues, nb_queues); + TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d", + test_dev_id_get(), ret); + return TEST_SUCCESS; +} + +static int +test_eventdev_link_get(void) +{ + int ret, nb_queues, i; + uint8_t queues[RTE_EVENT_MAX_QUEUES_PER_DEV]; + struct rte_event_queue_link links[RTE_EVENT_MAX_QUEUES_PER_DEV]; + + /* link all queues */ + ret = rte_event_port_link(test_dev_id_get(), 0, NULL, 0); + TEST_ASSERT(ret >= 0, "Failed to link with NULL device%d", + test_dev_id_get()); + + nb_queues = rte_event_queue_count(test_dev_id_get()); + for (i = 0; i < nb_queues; i++) + queues[i] = i; + + ret = rte_event_port_unlink(test_dev_id_get(), 0, queues, nb_queues); + TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d", + test_dev_id_get(), ret); + + ret = rte_event_port_links_get(test_dev_id_get(), 0, links); + TEST_ASSERT(ret == 0, "(%d)Wrong link get=%d", test_dev_id_get(), ret); + + /* link all queues and get the links */ + nb_queues = rte_event_queue_count(test_dev_id_get()); + for (i = 0; i < nb_queues; i++) { + links[i].queue_id = i; + links[i].priority = RTE_EVENT_QUEUE_SERVICE_PRIORITY_NORMAL; + } + ret = rte_event_port_link(test_dev_id_get(), 0, links, nb_queues); + TEST_ASSERT(ret == nb_queues, "Failed to link(device%d) ret=%d", + test_dev_id_get(), ret); + ret = rte_event_port_links_get(test_dev_id_get(), 0, links); + TEST_ASSERT(ret == nb_queues, "(%d)Wrong link get ret=%d expected=%d", + test_dev_id_get(), ret, nb_queues); + /* unlink all*/ + ret = rte_event_port_unlink(test_dev_id_get(), 0, NULL, 0); + TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d", + test_dev_id_get(), ret); + /* link just one queue */ + links[0].queue_id = 0; + links[0].priority = RTE_EVENT_QUEUE_SERVICE_PRIORITY_NORMAL; + + ret = rte_event_port_link(test_dev_id_get(), 0, links, 1); + TEST_ASSERT(ret == 1, "Failed to link(device%d) ret=%d", + test_dev_id_get(), ret); + ret = rte_event_port_links_get(test_dev_id_get(), 0, links); + TEST_ASSERT(ret == 1, "(%d)Wrong link get ret=%d expected=%d", + test_dev_id_get(), ret, 1); + /* unlink all*/ + ret = rte_event_port_unlink(test_dev_id_get(), 0, NULL, 0); + TEST_ASSERT(ret == nb_queues, "Failed to unlink(device%d) ret=%d", + test_dev_id_get(), ret); + /* 4links and 2 unlinks */ + nb_queues = rte_event_queue_count(test_dev_id_get()); + if (nb_queues >= 4) { + for (i = 0; i < 4; i++) { + links[i].queue_id = i; + links[i].priority = 0x40; + } + ret = rte_event_port_link(test_dev_id_get(), 0, links, 4); + TEST_ASSERT(ret == 4, "Failed to link(device%d) ret=%d", + test_dev_id_get(), ret); + + for (i = 0; i < 2; i++) + queues[i] = i; + + ret = rte_event_port_unlink(test_dev_id_get(), 0, queues, 2); + TEST_ASSERT(ret == 2, "Failed to unlink(device%d) ret=%d", + test_dev_id_get(), ret); + ret = rte_event_port_links_get(test_dev_id_get(), 0, links); + TEST_ASSERT(ret == 2, "(%d)Wrong link get ret=%d expected=%d", + test_dev_id_get(), ret, 2); + TEST_ASSERT(links[0].queue_id == 2, "ret=%d expected=%d", + ret, 2); + TEST_ASSERT(links[0].priority == 0x40, "ret=%d expected=%d", + ret, 0x40); + TEST_ASSERT(links[1].queue_id == 3, "ret=%d expected=%d", + ret, 3); + TEST_ASSERT(links[1].priority == 0x40, "ret=%d expected=%d", + ret, 0x40); + } + + return TEST_SUCCESS; +} + +static int +test_eventdev_close(void) +{ + rte_event_dev_stop(test_dev_id_get()); + return rte_event_dev_close(test_dev_id_get()); +} + +static struct unit_test_suite eventdev_common_testsuite = { + .suite_name = "eventdev common code unit test suite", + .setup = testsuite_setup, + .teardown = testsuite_teardown, + .unit_test_cases = { + TEST_CASE_ST(NULL, NULL, + test_eventdev_count), + TEST_CASE_ST(NULL, NULL, + test_eventdev_get_dev_id), + TEST_CASE_ST(NULL, NULL, + test_eventdev_socket_id), + TEST_CASE_ST(NULL, NULL, + test_eventdev_info_get), + TEST_CASE_ST(NULL, NULL, + test_eventdev_configure), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_queue_default_conf_get), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_queue_setup), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_queue_count), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_queue_priority), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_port_default_conf_get), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_port_setup), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_dequeue_depth), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_enqueue_depth), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_port_count), + TEST_CASE_ST(eventdev_configure_setup, NULL, + test_eventdev_wait_time), + TEST_CASE_ST(NULL, NULL, + test_eventdev_start_stop), + TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device, + test_eventdev_link), + TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device, + test_eventdev_unlink), + TEST_CASE_ST(eventdev_setup_device, eventdev_stop_device, + test_eventdev_link_get), + TEST_CASE_ST(eventdev_setup_device, NULL, + test_eventdev_close), + TEST_CASES_END() /**< NULL terminate unit test array */ + } +}; + +static int +test_eventdev_common(void) +{ + return unit_test_suite_runner(&eventdev_common_testsuite); +} + +REGISTER_TEST_COMMAND(eventdev_common_autotest, test_eventdev_common);