LCOV - code coverage report
Current view: top level - drivers/raw/skeleton - skeleton_rawdev_test.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 157 165 95.2 %
Date: 2024-04-01 19:00:53 Functions: 15 15 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 50 96 52.1 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2017 NXP
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <stdlib.h>
       6                 :            : 
       7                 :            : #include <rte_common.h>
       8                 :            : #include <rte_mbuf.h>
       9                 :            : #include <rte_malloc.h>
      10                 :            : #include <rte_memcpy.h>
      11                 :            : #include <dev_driver.h>
      12                 :            : #include <rte_rawdev.h>
      13                 :            : #include <bus_vdev_driver.h>
      14                 :            : #include <rte_test.h>
      15                 :            : 
      16                 :            : /* Using relative path as skeleton_rawdev is not part of exported headers */
      17                 :            : #include "skeleton_rawdev.h"
      18                 :            : 
      19                 :            : #define TEST_DEV_NAME "rawdev_skeleton"
      20                 :            : 
      21                 :            : #define SKELDEV_LOGS(level, fmt, args...) \
      22                 :            :         rte_log(RTE_LOG_ ## level, skeleton_pmd_logtype, fmt "\n", \
      23                 :            :                 ##args)
      24                 :            : 
      25                 :            : #define SKELDEV_TEST_INFO(fmt, args...) \
      26                 :            :         SKELDEV_LOGS(INFO, fmt, ## args)
      27                 :            : #define SKELDEV_TEST_DEBUG(fmt, args...) \
      28                 :            :         SKELDEV_LOGS(DEBUG, fmt, ## args)
      29                 :            : 
      30                 :            : #define SKELDEV_TEST_RUN(setup, teardown, test) \
      31                 :            :         skeldev_test_run(setup, teardown, test, #test)
      32                 :            : 
      33                 :            : #define TEST_SUCCESS 0
      34                 :            : #define TEST_FAILED  -1
      35                 :            : 
      36                 :            : static int total;
      37                 :            : static int passed;
      38                 :            : static int failed;
      39                 :            : static int unsupported;
      40                 :            : 
      41                 :            : static uint16_t test_dev_id;
      42                 :            : 
      43                 :            : static int
      44                 :          1 : testsuite_setup(void)
      45                 :            : {
      46                 :            :         uint8_t count;
      47                 :            : 
      48                 :          1 :         total = 0;
      49                 :          1 :         passed = 0;
      50                 :          1 :         failed = 0;
      51                 :          1 :         unsupported = 0;
      52                 :            : 
      53                 :          1 :         count = rte_rawdev_count();
      54         [ -  + ]:          1 :         if (!count) {
      55                 :          0 :                 SKELDEV_TEST_INFO("\tNo existing rawdev; "
      56                 :            :                                   "Creating 'skeldev_rawdev'");
      57                 :          0 :                 return rte_vdev_init(TEST_DEV_NAME, NULL);
      58                 :            :         }
      59                 :            : 
      60                 :            :         return TEST_SUCCESS;
      61                 :            : }
      62                 :            : 
      63                 :            : static void local_teardown(void);
      64                 :            : 
      65                 :            : static void
      66                 :            : testsuite_teardown(void)
      67                 :            : {
      68                 :            :         local_teardown();
      69                 :            : }
      70                 :            : 
      71                 :            : static void
      72                 :            : local_teardown(void)
      73                 :            : {
      74                 :          1 :         rte_vdev_uninit(TEST_DEV_NAME);
      75                 :            : }
      76                 :            : 
      77                 :            : static int
      78                 :          1 : test_rawdev_count(void)
      79                 :            : {
      80                 :            :         uint8_t count;
      81                 :          1 :         count = rte_rawdev_count();
      82         [ -  + ]:          1 :         RTE_TEST_ASSERT(count > 0, "Invalid rawdev count %" PRIu8, count);
      83                 :            :         return TEST_SUCCESS;
      84                 :            : }
      85                 :            : 
      86                 :            : static int
      87                 :          1 : test_rawdev_get_dev_id(void)
      88                 :            : {
      89                 :            :         int ret;
      90                 :          1 :         ret = rte_rawdev_get_dev_id("invalid_rawdev_device");
      91         [ -  + ]:          1 :         RTE_TEST_ASSERT_FAIL(ret, "Expected <0 for invalid dev name ret=%d",
      92                 :            :                              ret);
      93                 :            :         return TEST_SUCCESS;
      94                 :            : }
      95                 :            : 
      96                 :            : static int
      97                 :          1 : test_rawdev_socket_id(void)
      98                 :            : {
      99                 :            :         int socket_id;
     100                 :          1 :         socket_id = rte_rawdev_socket_id(test_dev_id);
     101         [ -  + ]:          1 :         RTE_TEST_ASSERT(socket_id != -EINVAL,
     102                 :            :                         "Failed to get socket_id %d", socket_id);
     103                 :          1 :         socket_id = rte_rawdev_socket_id(RTE_RAWDEV_MAX_DEVS);
     104         [ -  + ]:          1 :         RTE_TEST_ASSERT(socket_id == -EINVAL,
     105                 :            :                         "Expected -EINVAL %d", socket_id);
     106                 :            : 
     107                 :            :         return TEST_SUCCESS;
     108                 :            : }
     109                 :            : 
     110                 :            : static int
     111                 :          1 : test_rawdev_info_get(void)
     112                 :            : {
     113                 :            :         int ret;
     114                 :          1 :         struct rte_rawdev_info rdev_info = {0};
     115                 :          1 :         struct skeleton_rawdev_conf skel_conf = {0};
     116                 :            : 
     117                 :          1 :         ret = rte_rawdev_info_get(test_dev_id, NULL, 0);
     118         [ -  + ]:          1 :         RTE_TEST_ASSERT(ret == -EINVAL, "Expected -EINVAL, %d", ret);
     119                 :            : 
     120                 :          1 :         rdev_info.dev_private = &skel_conf;
     121                 :            : 
     122                 :          1 :         ret = rte_rawdev_info_get(test_dev_id, &rdev_info, sizeof(skel_conf));
     123         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get raw dev info");
     124                 :            : 
     125                 :            :         return TEST_SUCCESS;
     126                 :            : }
     127                 :            : 
     128                 :            : static int
     129                 :          3 : test_rawdev_configure(void)
     130                 :            : {
     131                 :            :         int ret;
     132                 :          3 :         struct rte_rawdev_info rdev_info = {0};
     133                 :          3 :         struct skeleton_rawdev_conf rdev_conf_set = {0};
     134                 :          3 :         struct skeleton_rawdev_conf rdev_conf_get = {0};
     135                 :            : 
     136                 :            :         /* Check invalid configuration */
     137                 :          3 :         ret = rte_rawdev_configure(test_dev_id, NULL, 0);
     138         [ -  + ]:          3 :         RTE_TEST_ASSERT(ret == -EINVAL,
     139                 :            :                         "Null configure; Expected -EINVAL, got %d", ret);
     140                 :            : 
     141                 :            :         /* Valid configuration test */
     142                 :          3 :         rdev_conf_set.num_queues = 1;
     143                 :          3 :         rdev_conf_set.capabilities = SKELETON_CAPA_FW_LOAD |
     144                 :            :                                      SKELETON_CAPA_FW_RESET;
     145                 :            : 
     146                 :          3 :         rdev_info.dev_private = &rdev_conf_set;
     147                 :          3 :         ret = rte_rawdev_configure(test_dev_id,
     148                 :            :                                    (rte_rawdev_obj_t)&rdev_info,
     149                 :            :                                    sizeof(rdev_conf_set));
     150         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to configure rawdev (%d)", ret);
     151                 :            : 
     152                 :          3 :         rdev_info.dev_private = &rdev_conf_get;
     153                 :          3 :         ret = rte_rawdev_info_get(test_dev_id,
     154                 :            :                                   (rte_rawdev_obj_t)&rdev_info,
     155                 :            :                                   sizeof(rdev_conf_get));
     156         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(ret,
     157                 :            :                                 "Failed to obtain rawdev configuration (%d)",
     158                 :            :                                 ret);
     159                 :            : 
     160         [ -  + ]:          3 :         RTE_TEST_ASSERT_EQUAL(rdev_conf_set.num_queues,
     161                 :            :                               rdev_conf_get.num_queues,
     162                 :            :                               "Configuration test failed; num_queues (%d)(%d)",
     163                 :            :                               rdev_conf_set.num_queues,
     164                 :            :                               rdev_conf_get.num_queues);
     165         [ -  + ]:          3 :         RTE_TEST_ASSERT_EQUAL(rdev_conf_set.capabilities,
     166                 :            :                           rdev_conf_get.capabilities,
     167                 :            :                           "Configuration test failed; capabilities");
     168                 :            : 
     169                 :            :         return TEST_SUCCESS;
     170                 :            : }
     171                 :            : 
     172                 :            : static int
     173                 :          1 : test_rawdev_queue_default_conf_get(void)
     174                 :            : {
     175                 :            :         int ret, i;
     176                 :          1 :         struct rte_rawdev_info rdev_info = {0};
     177                 :          1 :         struct skeleton_rawdev_conf rdev_conf_get = {0};
     178                 :          1 :         struct skeleton_rawdev_queue q = {0};
     179                 :            : 
     180                 :            :         /* Get the current configuration */
     181                 :          1 :         rdev_info.dev_private = &rdev_conf_get;
     182                 :          1 :         ret = rte_rawdev_info_get(test_dev_id,
     183                 :            :                                   (rte_rawdev_obj_t)&rdev_info,
     184                 :            :                                   sizeof(rdev_conf_get));
     185         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to obtain rawdev configuration (%d)",
     186                 :            :                                 ret);
     187                 :            : 
     188                 :            :         /* call to test_rawdev_configure would have set the num_queues = 1 */
     189         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0),
     190                 :            :                                 "Invalid number of queues (%d). Expected 1",
     191                 :            :                                 rdev_conf_get.num_queues);
     192                 :            :         /* All queues by default should have state = DETACH and
     193                 :            :          * depth = DEF_DEPTH
     194                 :            :          */
     195         [ +  + ]:          2 :         for (i = 0; i < rdev_conf_get.num_queues; i++) {
     196                 :          1 :                 rte_rawdev_queue_conf_get(test_dev_id, i, &q, sizeof(q));
     197         [ -  + ]:          1 :                 RTE_TEST_ASSERT_EQUAL(q.depth, SKELETON_QUEUE_DEF_DEPTH,
     198                 :            :                                       "Invalid default depth of queue (%d)",
     199                 :            :                                       q.depth);
     200         [ -  + ]:          1 :                 RTE_TEST_ASSERT_EQUAL(q.state, SKELETON_QUEUE_DETACH,
     201                 :            :                                       "Invalid default state of queue (%d)",
     202                 :            :                                       q.state);
     203                 :            :         }
     204                 :            : 
     205                 :            :         return TEST_SUCCESS;
     206                 :            : }
     207                 :            : 
     208                 :            : static int
     209                 :          1 : test_rawdev_queue_count(void)
     210                 :            : {
     211                 :            :         unsigned int q_count;
     212                 :            : 
     213                 :            :         /* Get the current configuration */
     214                 :          1 :         q_count = rte_rawdev_queue_count(test_dev_id);
     215         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(q_count, 1, "Invalid queue count (%d)", q_count);
     216                 :            : 
     217                 :            :         return TEST_SUCCESS;
     218                 :            : }
     219                 :            : 
     220                 :            : static int
     221                 :          3 : test_rawdev_queue_setup(void)
     222                 :            : {
     223                 :            :         int ret;
     224                 :          3 :         struct rte_rawdev_info rdev_info = {0};
     225                 :          3 :         struct skeleton_rawdev_conf rdev_conf_get = {0};
     226                 :          3 :         struct skeleton_rawdev_queue qset = {0};
     227                 :          3 :         struct skeleton_rawdev_queue qget = {0};
     228                 :            : 
     229                 :            :         /* Get the current configuration */
     230                 :          3 :         rdev_info.dev_private = &rdev_conf_get;
     231                 :          3 :         ret = rte_rawdev_info_get(test_dev_id,
     232                 :            :                                   (rte_rawdev_obj_t)&rdev_info,
     233                 :            :                                   sizeof(rdev_conf_get));
     234         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(ret,
     235                 :            :                                 "Failed to obtain rawdev configuration (%d)",
     236                 :            :                                 ret);
     237                 :            : 
     238                 :            :         /* call to test_rawdev_configure would have set the num_queues = 1 */
     239         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(!(rdev_conf_get.num_queues > 0),
     240                 :            :                                 "Invalid number of queues (%d). Expected 1",
     241                 :            :                                 rdev_conf_get.num_queues);
     242                 :            : 
     243                 :            :         /* Modify the queue depth for Queue 0 and attach it */
     244                 :          3 :         qset.depth = 15;
     245                 :          3 :         qset.state = SKELETON_QUEUE_ATTACH;
     246                 :          3 :         ret = rte_rawdev_queue_setup(test_dev_id, 0, &qset, sizeof(qset));
     247         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to setup queue (%d)", ret);
     248                 :            : 
     249                 :            :         /* Now, fetching the queue 0 should show depth as 15 */
     250                 :          3 :         ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget, sizeof(qget));
     251         [ -  + ]:          3 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret);
     252                 :            : 
     253         [ -  + ]:          3 :         RTE_TEST_ASSERT_EQUAL(qset.depth, qget.depth,
     254                 :            :                               "Failed to set queue depth: Need(%d), has(%d)",
     255                 :            :                               qset.depth, qget.depth);
     256                 :            : 
     257                 :            :         return TEST_SUCCESS;
     258                 :            : }
     259                 :            : 
     260                 :            : /* After executing test_rawdev_queue_setup, queue_id=0 would have depth as 15.
     261                 :            :  * Releasing should set it back to default. state would set to DETACH
     262                 :            :  */
     263                 :            : static int
     264                 :          1 : test_rawdev_queue_release(void)
     265                 :            : {
     266                 :            :         int ret;
     267                 :          1 :         struct skeleton_rawdev_queue qget = {0};
     268                 :            : 
     269                 :            :         /* Now, fetching the queue 0 should show depth as 100 */
     270                 :          1 :         ret = rte_rawdev_queue_release(test_dev_id, 0);
     271         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to release queue 0; (%d)", ret);
     272                 :            : 
     273                 :            :         /* Now, fetching the queue 0 should show depth as default */
     274                 :          1 :         ret = rte_rawdev_queue_conf_get(test_dev_id, 0, &qget, sizeof(qget));
     275         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to get queue config (%d)", ret);
     276                 :            : 
     277         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(qget.depth, SKELETON_QUEUE_DEF_DEPTH,
     278                 :            :                               "Release of Queue 0 failed; (depth)");
     279                 :            : 
     280         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(qget.state, SKELETON_QUEUE_DETACH,
     281                 :            :                               "Release of Queue 0 failed; (state)");
     282                 :            : 
     283                 :            :         return TEST_SUCCESS;
     284                 :            : }
     285                 :            : 
     286                 :            : static int
     287                 :          1 : test_rawdev_attr_set_get(void)
     288                 :            : {
     289                 :            :         int ret;
     290                 :            :         int *dummy_value, set_value;
     291                 :            :         uint64_t ret_value;
     292                 :            : 
     293                 :            :         /* Set an attribute and fetch it */
     294                 :          1 :         ret = rte_rawdev_set_attr(test_dev_id, "Test1", 100);
     295         [ -  + ]:          1 :         RTE_TEST_ASSERT(!ret, "Unable to set an attribute (Test1)");
     296                 :            : 
     297                 :            :         dummy_value = &set_value;
     298                 :          1 :         *dummy_value = 200;
     299                 :          1 :         ret = rte_rawdev_set_attr(test_dev_id, "Test2", (uintptr_t)dummy_value);
     300         [ -  + ]:          1 :         RTE_TEST_ASSERT(!ret, "Unable to set an attribute (Test2)");
     301                 :            : 
     302                 :            :         /* Check if attributes have been set */
     303                 :          1 :         ret = rte_rawdev_get_attr(test_dev_id, "Test1", &ret_value);
     304         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(ret_value, 100,
     305                 :            :                               "Attribute (Test1) not set correctly (%" PRIu64 ")",
     306                 :            :                               ret_value);
     307                 :            : 
     308                 :          1 :         ret_value = 0;
     309                 :          1 :         ret = rte_rawdev_get_attr(test_dev_id, "Test2", &ret_value);
     310         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(*((int *)(uintptr_t)ret_value), set_value,
     311                 :            :                               "Attribute (Test2) not set correctly (%" PRIu64 ")",
     312                 :            :                               ret_value);
     313                 :            : 
     314                 :            :         return TEST_SUCCESS;
     315                 :            : }
     316                 :            : 
     317                 :            : static int
     318                 :          1 : test_rawdev_start_stop(void)
     319                 :            : {
     320                 :            :         int ret;
     321                 :          1 :         struct rte_rawdev_info rdev_info = {0};
     322                 :          1 :         struct skeleton_rawdev_conf rdev_conf_get = {0};
     323                 :            :         char *dummy_firmware = NULL;
     324                 :            : 
     325                 :            :         /* Get the current configuration */
     326                 :          1 :         rdev_info.dev_private = &rdev_conf_get;
     327                 :            : 
     328                 :            :         /* Load a firmware using a dummy address area */
     329                 :          1 :         dummy_firmware = rte_zmalloc("RAWDEV SKELETON", sizeof(int) * 10, 0);
     330         [ -  + ]:          1 :         RTE_TEST_ASSERT(dummy_firmware != NULL,
     331                 :            :                         "Failed to create firmware memory backing");
     332                 :            : 
     333                 :          1 :         ret = rte_rawdev_firmware_load(test_dev_id, dummy_firmware);
     334         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Firmware loading failed (%d)", ret);
     335                 :            : 
     336                 :            :         /* Skeleton doesn't do anything with the firmware area - that is dummy
     337                 :            :          * and can be removed.
     338                 :            :          */
     339                 :          1 :         rte_free(dummy_firmware);
     340                 :            :         dummy_firmware = NULL;
     341                 :            : 
     342                 :          1 :         rte_rawdev_start(test_dev_id);
     343                 :          1 :         ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info,
     344                 :            :                         sizeof(rdev_conf_get));
     345         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret,
     346                 :            :                                 "Failed to obtain rawdev configuration (%d)",
     347                 :            :                                 ret);
     348         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_RUNNING,
     349                 :            :                               "Device start failed. State is (%d)",
     350                 :            :                               rdev_conf_get.device_state);
     351                 :            : 
     352                 :          1 :         rte_rawdev_stop(test_dev_id);
     353                 :          1 :         ret = rte_rawdev_info_get(test_dev_id, (rte_rawdev_obj_t)&rdev_info,
     354                 :            :                         sizeof(rdev_conf_get));
     355         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret,
     356                 :            :                                 "Failed to obtain rawdev configuration (%d)",
     357                 :            :                                 ret);
     358         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(rdev_conf_get.device_state, SKELETON_DEV_STOPPED,
     359                 :            :                               "Device stop failed. State is (%d)",
     360                 :            :                               rdev_conf_get.device_state);
     361                 :            : 
     362                 :            :         /* Unloading the firmware once device is stopped */
     363                 :          1 :         ret = rte_rawdev_firmware_unload(test_dev_id);
     364         [ -  + ]:          1 :         RTE_TEST_ASSERT_SUCCESS(ret, "Failed to unload firmware (%d)", ret);
     365                 :            : 
     366                 :            :         return TEST_SUCCESS;
     367                 :            : }
     368                 :            : 
     369                 :            : static int
     370                 :          1 : test_rawdev_enqdeq(void)
     371                 :            : {
     372                 :            :         int ret;
     373                 :          1 :         uint16_t queue_id = 0;
     374                 :            :         struct rte_rawdev_buf buffer;
     375                 :            :         struct rte_rawdev_buf *buffers[1];
     376                 :            :         struct rte_rawdev_buf deq_buffer;
     377                 :            :         struct rte_rawdev_buf *deq_buffers[1];
     378                 :            : 
     379                 :          1 :         buffers[0] = &buffer;
     380                 :          1 :         buffer.buf_addr = malloc(strlen(TEST_DEV_NAME) + 3);
     381         [ +  - ]:          1 :         if (!buffer.buf_addr)
     382                 :            :                 return TEST_FAILED;
     383                 :            :         snprintf(buffer.buf_addr, strlen(TEST_DEV_NAME) + 2, "%s%d",
     384                 :            :                  TEST_DEV_NAME, 0);
     385                 :            : 
     386                 :          1 :         ret = rte_rawdev_enqueue_buffers(test_dev_id, buffers,
     387                 :            :                                          RTE_DIM(buffers), &queue_id);
     388         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL((unsigned int)ret, RTE_DIM(buffers),
     389                 :            :                               "Unable to enqueue buffers");
     390                 :            : 
     391                 :          1 :         deq_buffers[0] = &deq_buffer;
     392                 :          1 :         ret = rte_rawdev_dequeue_buffers(test_dev_id, deq_buffers,
     393                 :            :                                         RTE_DIM(deq_buffers), &queue_id);
     394         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL((unsigned int)ret, RTE_DIM(buffers),
     395                 :            :                               "Unable to dequeue buffers");
     396         [ -  + ]:          1 :         RTE_TEST_ASSERT_EQUAL(deq_buffers[0]->buf_addr, buffers[0]->buf_addr,
     397                 :            :                               "Did not retrieve expected object");
     398                 :            : 
     399                 :          1 :         free(buffer.buf_addr);
     400                 :          1 :         return TEST_SUCCESS;
     401                 :            : }
     402                 :            : 
     403                 :         12 : static void skeldev_test_run(int (*setup)(void),
     404                 :            :                              void (*teardown)(void),
     405                 :            :                              int (*test)(void),
     406                 :            :                              const char *name)
     407                 :            : {
     408                 :            :         int ret = 0;
     409                 :            : 
     410         [ +  + ]:         12 :         if (setup) {
     411                 :          4 :                 ret = setup();
     412         [ -  + ]:          4 :                 if (ret < 0) {
     413                 :          0 :                         SKELDEV_TEST_INFO("Error setting up test %s", name);
     414                 :          0 :                         unsupported++;
     415                 :            :                 }
     416                 :            :         }
     417                 :            : 
     418         [ +  - ]:         12 :         if (test) {
     419                 :         12 :                 ret = test();
     420         [ -  + ]:         12 :                 if (ret < 0) {
     421                 :          0 :                         failed++;
     422                 :          0 :                         SKELDEV_TEST_INFO("%s Failed", name);
     423                 :            :                 } else {
     424                 :         12 :                         passed++;
     425                 :         12 :                         SKELDEV_TEST_DEBUG("%s Passed", name);
     426                 :            :                 }
     427                 :            :         }
     428                 :            : 
     429         [ -  + ]:         12 :         if (teardown)
     430                 :          0 :                 teardown();
     431                 :            : 
     432                 :         12 :         total++;
     433                 :         12 : }
     434                 :            : 
     435                 :            : int
     436                 :          1 : test_rawdev_skeldev(uint16_t dev_id)
     437                 :            : {
     438                 :          1 :         test_dev_id = dev_id;
     439                 :          1 :         testsuite_setup();
     440                 :            : 
     441                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_count);
     442                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_get_dev_id);
     443                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_socket_id);
     444                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_info_get);
     445                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_configure);
     446                 :          1 :         SKELDEV_TEST_RUN(test_rawdev_configure, NULL,
     447                 :            :                          test_rawdev_queue_default_conf_get);
     448                 :          1 :         SKELDEV_TEST_RUN(test_rawdev_configure, NULL, test_rawdev_queue_setup);
     449                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_queue_count);
     450                 :          1 :         SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL,
     451                 :            :                          test_rawdev_queue_release);
     452                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_attr_set_get);
     453                 :          1 :         SKELDEV_TEST_RUN(NULL, NULL, test_rawdev_start_stop);
     454                 :          1 :         SKELDEV_TEST_RUN(test_rawdev_queue_setup, NULL, test_rawdev_enqdeq);
     455                 :            : 
     456                 :            :         testsuite_teardown();
     457                 :            : 
     458                 :          1 :         SKELDEV_TEST_INFO("Total tests   : %d", total);
     459                 :          1 :         SKELDEV_TEST_INFO("Passed        : %d", passed);
     460                 :          1 :         SKELDEV_TEST_INFO("Failed        : %d", failed);
     461                 :          1 :         SKELDEV_TEST_INFO("Not supported : %d", unsupported);
     462                 :            : 
     463         [ -  + ]:          1 :         if (failed)
     464                 :          0 :                 return -1;
     465                 :            : 
     466                 :            :         return 0;
     467                 :            : };

Generated by: LCOV version 1.14