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