test/metrics: fix second run
[dpdk.git] / 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);