test: move to app directory
[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  /* 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);