app/test/test_metrics.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2018 Intel Corporation
   3  */
   4
   5 #include <stdio.h>
   6 #include <string.h>
   7 #include <stdint.h>
   8 #include <errno.h>
   9
  10 #include <rte_lcore.h>
  11 #include <rte_metrics.h>
  12
  13 #include "test.h"
  14
  15 #define REG_METRIC_COUNT        6
  16 #define METRIC_LESSER_COUNT     3
  17 #define KEY     1
  18 #define VALUE   1
  19
  20 /* Initializes metric module. This function must be called
  21  * from a primary process before metrics are used
  22  */
  23 static int
  24 test_metrics_init(void)
  25 {
  26         rte_metrics_init(rte_socket_id());
  27         return TEST_SUCCESS;
  28 }
  29
  30 /* Deinitialize metric module. This function must be called
  31  * from a primary process after metrics usage is over
  32  */
  33 static int
  34 test_metrics_deinitialize(void)
  35 {
  36         int err = 0;
  37         err = rte_metrics_deinit();
  38         TEST_ASSERT(err == 0, "%s, %d", __func__, __LINE__);
  39
  40         return TEST_SUCCESS;
  41 }
  42
  43  /* Test Case to check failures when memzone init is not done */
  44 static int
  45 test_metrics_without_init(void)
  46 {
  47         int err = 0;
  48         const uint64_t  value[REG_METRIC_COUNT] = {0};
  49         const char * const mnames[] = {
  50                 "mean_bits_in", "mean_bits_out",
  51                 "peak_bits_in", "peak_bits_out",
  52         };
  53
  54         /* Failure Test: Checking for memzone initialization */
  55         err = rte_metrics_reg_name("peak_bits_in");
  56         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  57
  58         err = rte_metrics_reg_names(&mnames[0], 1);
  59         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  60
  61         err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY, VALUE);
  62         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  63
  64         err = rte_metrics_update_values(RTE_METRICS_GLOBAL, KEY, &value[0], 4);
  65         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  66
  67         err = rte_metrics_get_names(NULL, 0);
  68         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  69
  70         err = rte_metrics_get_values(RTE_METRICS_GLOBAL, NULL, 0);
  71         TEST_ASSERT(err == -EIO, "%s, %d", __func__, __LINE__);
  72
  73         return TEST_SUCCESS;
  74 }
  75
  76 /* Test Case to validate registering a single metric */
  77 static int
  78 test_metrics_reg_name_with_validname(void)
  79 {
  80         int err = 0;
  81
  82         /* Test to register the new metric name */
  83         err = rte_metrics_reg_name("peak_bits_out");
  84         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
  85
  86         /* Test to register the same metric name */
  87         err = rte_metrics_reg_name("peak_bits_out");
  88         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
  89
  90         /* Test case to validate registering a invalid metric */
  91         err = rte_metrics_reg_name(NULL);
  92         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
  93
  94         return TEST_SUCCESS;
  95 }
  96
  97 /* Test case to validate registering a list of valid  metric names */
  98 static int
  99 test_metrics_reg_names(void)
 100 {
 101         int err = 0;
 102         const char * const mnames[] = {
 103                 "mean_bits_in", "mean_bits_out",
 104                 "peak_bits_in", "peak_bits_out",
 105                 };
 106
 107         /* Success Test: valid array and count size */
 108         err = rte_metrics_reg_names(&mnames[0], RTE_DIM(mnames));
 109         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 110
 111         return TEST_SUCCESS;
 112 }
 113
 114 /* Test case to validate update a metric */
 115 static int
 116 test_metrics_update_value(void)
 117 {
 118         int err = 0;
 119
 120         /* Successful Test: Valid port_id, key and value */
 121         err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY, VALUE);
 122         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 123
 124         /* Successful Test: Valid port_id otherthan RTE_METRICS_GLOBAL, key
 125          * and value
 126          */
 127         err = rte_metrics_update_value(9, KEY, VALUE);
 128         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 129
 130         /* Failed Test: Invalid port_id with lower value */
 131         err = rte_metrics_update_value(-2, KEY, VALUE);
 132         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 133
 134         /* Failed Test: Invalid port_id with higher value */
 135         err = rte_metrics_update_value(39, KEY, VALUE);
 136         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 137
 138         /* Failed Test: valid port id, value with invalid key */
 139         err = rte_metrics_update_value(RTE_METRICS_GLOBAL, KEY+12, VALUE);
 140         TEST_ASSERT(err < 0, "%s, %d", __func__, __LINE__);
 141
 142         return TEST_SUCCESS;
 143 }
 144
 145 /* Test case to validate update a list of  metrics  */
 146 static int
 147 test_metrics_update_values(void)
 148 {
 149         int err = 0;
 150         const uint64_t  value[REG_METRIC_COUNT] = {1, 2, 3, 4, 5, 6};
 151
 152         /* Successful Test: update metrics with first set */
 153         err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 0,
 154                         &value[0], 1);
 155         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 156
 157         /* Successful Test: update metrics with second set */
 158         err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 1,
 159                         &value[1], 1);
 160         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 161
 162         /* Successful Test: update metrics with third set */
 163         err = rte_metrics_update_values(RTE_METRICS_GLOBAL, 2,
 164                         &value[2], 4);
 165         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 166
 167         /* Failed Test: Invalid count size */
 168         err = rte_metrics_update_values(RTE_METRICS_GLOBAL,
 169                          KEY, &value[0], RTE_DIM(value));
 170         TEST_ASSERT(err < 0, "%s, %d", __func__, __LINE__);
 171
 172         /* Failed Test: Invalid port_id(lower value) and valid data */
 173         err = rte_metrics_update_values(-2, KEY, &value[0], RTE_DIM(value));
 174         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 175
 176         /* Failed Test: Invalid port_id(higher value) and valid data */
 177         err = rte_metrics_update_values(39, 1, &value[0], RTE_DIM(value));
 178         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 179
 180         /* Failed Test: Invalid array */
 181         err = rte_metrics_update_values(RTE_METRICS_GLOBAL,
 182                          KEY, NULL, RTE_DIM(value));
 183         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 184
 185         return TEST_SUCCESS;
 186 }
 187
 188 /* Test to validate get metric name-key lookup table */
 189 static int
 190 test_metrics_get_names(void)
 191 {
 192         int err = 0;
 193         struct rte_metric_name metrics[METRIC_LESSER_COUNT];
 194         struct rte_metric_name success_metrics[REG_METRIC_COUNT];
 195
 196         /* Successful Test: Invalid array list */
 197         err = rte_metrics_get_names(NULL, 0);
 198         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 199
 200         /* Successful Test: Valid array list, Correct Count Stats same
 201          * as memzone stats
 202          */
 203         err = rte_metrics_get_names(success_metrics, REG_METRIC_COUNT);
 204         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 205
 206         /* Successful Test: Valid array list, Increase Count Stats than
 207          * memzone stats
 208          */
 209         err = rte_metrics_get_names(success_metrics, REG_METRIC_COUNT+5);
 210         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 211
 212         /* Successful Test, Not update results:
 213          * Invalid array list, Lesser Count Stats than allocated stats
 214          */
 215         err = rte_metrics_get_names(metrics, METRIC_LESSER_COUNT);
 216         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 217
 218         return TEST_SUCCESS;
 219 }
 220
 221 /* Test to validate get list of metric values  */
 222 static int
 223 test_metrics_get_values(void)
 224 {
 225         int i = 0;
 226         int err = 0;
 227         struct rte_metric_value getvalues[REG_METRIC_COUNT];
 228
 229         size_t m_size = sizeof(struct rte_metric_value);
 230         for (i = 0; i < REG_METRIC_COUNT; i++)
 231                 memset(&getvalues[i], 0, m_size);
 232
 233         /* Successful Test, Not update results: valid arguments
 234          * count lessthan the memzone stats
 235          */
 236         err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues,
 237                          METRIC_LESSER_COUNT);
 238         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 239
 240         /* Successful Test, update results: valid arguments */
 241         err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues,
 242                          REG_METRIC_COUNT);
 243         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 244
 245         /* Successful Test : valid arguments count greaterthan the
 246          * memzone stats
 247          */
 248         err = rte_metrics_get_values(RTE_METRICS_GLOBAL, getvalues,
 249                         REG_METRIC_COUNT+2);
 250         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 251
 252         /* Failure Test: Invalid port_id(lower value) with correct values
 253          * and  Capacity
 254          */
 255         err = rte_metrics_get_values(-2, getvalues, REG_METRIC_COUNT);
 256         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 257
 258         /* Failure Test: Invalid port_id(higher value) with correct values
 259          * and  Capacity
 260          */
 261         err = rte_metrics_get_values(33, getvalues, REG_METRIC_COUNT);
 262         TEST_ASSERT(err == -EINVAL, "%s, %d", __func__, __LINE__);
 263
 264         /* Successful Test: valid port_id with incorrect values and  valid
 265          * capacity
 266          */
 267         err = rte_metrics_get_values(RTE_METRICS_GLOBAL, NULL,
 268                          REG_METRIC_COUNT);
 269         TEST_ASSERT(err >= 0, "%s, %d", __func__, __LINE__);
 270
 271         return TEST_SUCCESS;
 272 }
 273
 274 static struct unit_test_suite metrics_testsuite  = {
 275         .suite_name = "Metrics Unit Test Suite",
 276         .setup = NULL,
 277         .teardown = NULL,
 278         .unit_test_cases = {
 279                 /* Test Case 1: Test to check all metric APIs without
 280                  * metrics init
 281                  */
 282                 TEST_CASE(test_metrics_without_init),
 283
 284                 /* TEST CASE 2: Test to register valid metrics*/
 285                 TEST_CASE_ST(test_metrics_init, NULL,
 286                                 test_metrics_reg_name_with_validname),
 287
 288                 /* TEST CASE 3: Test to register list of metrics with valid
 289                  * names and valid count size, invalid names and invalid
 290                  * count size
 291                  */
 292                 TEST_CASE(test_metrics_reg_names),
 293
 294                 /* TEST CASE 4: Test to register a update value with valid port
 295                  * id and invalid port id
 296                  */
 297                 TEST_CASE(test_metrics_update_value),
 298
 299                 /* TEST CASE 5: Test to register update list of values with
 300                  * valid port id, key, value, count size and invalid port id,
 301                  * key, value, count size
 302                  */
 303                 TEST_CASE(test_metrics_update_values),
 304
 305                 /* TEST CASE 6: Test to get metric names-key with valid
 306                  * array list, count size and invalid array list, count size
 307                  */
 308                 TEST_CASE(test_metrics_get_names),
 309
 310                 /* TEST CASE 7: Test to get list of metric values with valid
 311                  * port id, array list, count size and invalid port id,
 312                  * arraylist, count size
 313                  */
 314                 TEST_CASE(test_metrics_get_values),
 315
 316                 /* TEST CASE 8: Test to unregister metrics*/
 317                 TEST_CASE(test_metrics_deinitialize),
 318
 319                 TEST_CASES_END()
 320         }
 321 };
 322
 323 static int
 324 test_metrics(void)
 325 {
 326         return unit_test_suite_runner(&metrics_testsuite);
 327 }
 328
 329 REGISTER_TEST_COMMAND(metrics_autotest, test_metrics);