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