1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright 2020 Intel Corporation 3 */ 4 5 #ifdef RTE_EXEC_ENV_WINDOWS 6 #include "test.h" 7 8 static int 9 telemetry_data_autotest(void) 10 { 11 return TEST_SKIPPED; 12 } 13 14 #else 15 16 #include <string.h> 17 #include <sys/socket.h> 18 #include <sys/un.h> 19 #include <unistd.h> 20 #include <limits.h> 21 22 #include <rte_eal.h> 23 #include <rte_common.h> 24 #include <rte_telemetry.h> 25 #include <rte_string_fns.h> 26 27 #include "test.h" 28 #include "telemetry_data.h" 29 30 #define TELEMETRY_VERSION "v2" 31 #define REQUEST_CMD "/test" 32 #define BUF_SIZE 1024 33 #define CHECK_OUTPUT(exp) check_output(__func__, "{\"" REQUEST_CMD "\":" exp "}") 34 35 /* 36 * Runs a series of test cases, checking the output of telemetry for various different types of 37 * responses. On init, a single connection to DPDK telemetry is made, and a single telemetry 38 * callback "/test" is registered. That callback always returns the value of the static global 39 * variable "response_data", so each test case builds up that structure, and then calls the 40 * "check_output" function to ensure the response received over the socket for "/test" matches 41 * that expected for the response_data value populated. 42 * 43 * NOTE: 44 * - each test case function in this file should be added to the "test_cases" array in 45 * test_telemetry_data function at the bottom of the file. 46 * - each test case function should populate the "response_data" global variable (below) 47 * with the appropriate values which would be returned from a simulated telemetry function. 48 * Then the test case function should have "return CHECK_OUTPUT(<expected_data>);" as it's 49 * last line. The test infrastructure will then validate that the output when returning 50 * "response_data" structure matches that in "<expected_data>". 51 * - the response_data structure will be zeroed on entry to each test function, so each function 52 * can begin with a call to "rte_tel_data_string/start_array/start_dict" as so desired. 53 * - the expected_output for each function can be just the actual json data from the 54 * "response_data" value. The CHECK_OUTPUT macro will include the appropriate "{\"/test\": ... }" 55 * structure around the json output. 56 * 57 * See test_simple_string(), or test_case_array_int() for a basic examples of test cases. 58 */ 59 60 61 static struct rte_tel_data response_data; 62 static int sock; 63 64 65 /* 66 * This function is the callback registered with Telemetry to be used when 67 * the /test command is requested. This callback returns the global data built 68 * up by the individual test cases. 69 */ 70 static int 71 telemetry_test_cb(const char *cmd __rte_unused, const char *params __rte_unused, 72 struct rte_tel_data *d) 73 { 74 *d = response_data; 75 return 0; 76 } 77 78 /* 79 * This function is called by each test case function. It communicates with 80 * the telemetry socket by requesting the /test command, and reading the 81 * response. The expected response is passed in by the test case function, 82 * and is compared to the actual response received from Telemetry. 83 */ 84 static int 85 check_output(const char *func_name, const char *expected) 86 { 87 int bytes; 88 char buf[BUF_SIZE * 16]; 89 if (write(sock, REQUEST_CMD, strlen(REQUEST_CMD)) < 0) { 90 printf("%s: Error with socket write - %s\n", __func__, 91 strerror(errno)); 92 return -1; 93 } 94 bytes = read(sock, buf, sizeof(buf) - 1); 95 if (bytes < 0) { 96 printf("%s: Error with socket read - %s\n", __func__, 97 strerror(errno)); 98 return -1; 99 } 100 buf[bytes] = '\0'; 101 printf("%s: buf = '%s', expected = '%s'\n", func_name, buf, expected); 102 return strncmp(expected, buf, sizeof(buf)); 103 } 104 105 static int 106 test_null_return(void) 107 { 108 return CHECK_OUTPUT("null"); 109 } 110 111 static int 112 test_simple_string(void) 113 { 114 rte_tel_data_string(&response_data, "Simple string"); 115 116 return CHECK_OUTPUT("\"Simple string\""); 117 } 118 119 static int 120 test_dict_with_array_int_values(void) 121 { 122 int i; 123 124 struct rte_tel_data *child_data = rte_tel_data_alloc(); 125 rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL); 126 127 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 128 rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); 129 130 rte_tel_data_start_dict(&response_data); 131 132 for (i = 0; i < 5; i++) { 133 rte_tel_data_add_array_int(child_data, i); 134 rte_tel_data_add_array_int(child_data2, i); 135 } 136 137 rte_tel_data_add_dict_container(&response_data, "dict_0", 138 child_data, 0); 139 rte_tel_data_add_dict_container(&response_data, "dict_1", 140 child_data2, 0); 141 142 return CHECK_OUTPUT("{\"dict_0\":[0,1,2,3,4],\"dict_1\":[0,1,2,3,4]}"); 143 } 144 145 static int 146 test_array_with_array_int_values(void) 147 { 148 int i; 149 150 struct rte_tel_data *child_data = rte_tel_data_alloc(); 151 rte_tel_data_start_array(child_data, RTE_TEL_INT_VAL); 152 153 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 154 rte_tel_data_start_array(child_data2, RTE_TEL_INT_VAL); 155 156 rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); 157 158 for (i = 0; i < 5; i++) { 159 rte_tel_data_add_array_int(child_data, i); 160 rte_tel_data_add_array_int(child_data2, i); 161 } 162 rte_tel_data_add_array_container(&response_data, child_data, 0); 163 rte_tel_data_add_array_container(&response_data, child_data2, 0); 164 165 return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]"); 166 } 167 168 static int 169 test_case_array_int(void) 170 { 171 int i; 172 173 rte_tel_data_start_array(&response_data, RTE_TEL_INT_VAL); 174 for (i = 0; i < 5; i++) 175 rte_tel_data_add_array_int(&response_data, i); 176 return CHECK_OUTPUT("[0,1,2,3,4]"); 177 } 178 179 static int 180 test_case_add_dict_int(void) 181 { 182 int i = 0; 183 char name_of_value[8]; 184 185 rte_tel_data_start_dict(&response_data); 186 187 for (i = 0; i < 5; i++) { 188 sprintf(name_of_value, "dict_%d", i); 189 rte_tel_data_add_dict_int(&response_data, name_of_value, i); 190 } 191 192 return CHECK_OUTPUT("{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,\"dict_3\":3,\"dict_4\":4}"); 193 } 194 195 static int 196 test_case_array_string(void) 197 { 198 rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); 199 rte_tel_data_add_array_string(&response_data, "aaaa"); 200 rte_tel_data_add_array_string(&response_data, "bbbb"); 201 rte_tel_data_add_array_string(&response_data, "cccc"); 202 rte_tel_data_add_array_string(&response_data, "dddd"); 203 rte_tel_data_add_array_string(&response_data, "eeee"); 204 205 return CHECK_OUTPUT("[\"aaaa\",\"bbbb\",\"cccc\",\"dddd\",\"eeee\"]"); 206 } 207 208 static int 209 test_case_add_dict_string(void) 210 { 211 rte_tel_data_start_dict(&response_data); 212 213 rte_tel_data_add_dict_string(&response_data, "dict_0", "aaaa"); 214 rte_tel_data_add_dict_string(&response_data, "dict_1", "bbbb"); 215 rte_tel_data_add_dict_string(&response_data, "dict_2", "cccc"); 216 rte_tel_data_add_dict_string(&response_data, "dict_3", "dddd"); 217 218 return CHECK_OUTPUT("{\"dict_0\":\"aaaa\",\"dict_1\":\"bbbb\",\"dict_2\":\"cccc\",\"dict_3\":\"dddd\"}"); 219 } 220 221 static int 222 test_case_add_dict_uint_hex_padding(void) 223 { 224 rte_tel_data_start_dict(&response_data); 225 226 rte_tel_data_add_dict_uint_hex(&response_data, "dict_0", 227 (uint8_t)0x8, 8); 228 rte_tel_data_add_dict_uint_hex(&response_data, "dict_1", 229 (uint16_t)0x88, 16); 230 rte_tel_data_add_dict_uint_hex(&response_data, "dict_2", 231 (uint32_t)0x888, 32); 232 rte_tel_data_add_dict_uint_hex(&response_data, "dict_3", 233 (uint64_t)0x8888, 64); 234 235 return CHECK_OUTPUT("{\"dict_0\":\"0x08\",\"dict_1\":\"0x0088\",\"dict_2\":\"0x00000888\",\"dict_3\":\"0x0000000000008888\"}"); 236 } 237 238 static int 239 test_case_add_dict_uint_hex_nopadding(void) 240 { 241 rte_tel_data_start_dict(&response_data); 242 243 rte_tel_data_add_dict_uint_hex(&response_data, "dict_0", 244 (uint8_t)0x8, 0); 245 rte_tel_data_add_dict_uint_hex(&response_data, "dict_1", 246 (uint16_t)0x88, 0); 247 rte_tel_data_add_dict_uint_hex(&response_data, "dict_2", 248 (uint32_t)0x888, 0); 249 rte_tel_data_add_dict_uint_hex(&response_data, "dict_3", 250 (uint64_t)0x8888, 0); 251 252 return CHECK_OUTPUT("{\"dict_0\":\"0x8\",\"dict_1\":\"0x88\",\"dict_2\":\"0x888\",\"dict_3\":\"0x8888\"}"); 253 } 254 255 static int 256 test_dict_with_array_string_values(void) 257 { 258 struct rte_tel_data *child_data = rte_tel_data_alloc(); 259 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 260 261 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 262 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 263 264 rte_tel_data_start_dict(&response_data); 265 266 rte_tel_data_add_array_string(child_data, "aaaa"); 267 rte_tel_data_add_array_string(child_data2, "bbbb"); 268 269 rte_tel_data_add_dict_container(&response_data, "dict_0", 270 child_data, 0); 271 rte_tel_data_add_dict_container(&response_data, "dict_1", 272 child_data2, 0); 273 274 return CHECK_OUTPUT("{\"dict_0\":[\"aaaa\"],\"dict_1\":[\"bbbb\"]}"); 275 } 276 277 static int 278 test_dict_with_array_uint_hex_values_padding(void) 279 { 280 struct rte_tel_data *child_data = rte_tel_data_alloc(); 281 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 282 283 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 284 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 285 286 rte_tel_data_start_dict(&response_data); 287 288 rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 32); 289 rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 64); 290 291 rte_tel_data_add_dict_container(&response_data, "dict_0", 292 child_data, 0); 293 rte_tel_data_add_dict_container(&response_data, "dict_1", 294 child_data2, 0); 295 296 return CHECK_OUTPUT("{\"dict_0\":[\"0x00000888\"],\"dict_1\":[\"0x0000000000008888\"]}"); 297 } 298 299 static int 300 test_dict_with_array_uint_hex_values_nopadding(void) 301 { 302 struct rte_tel_data *child_data = rte_tel_data_alloc(); 303 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 304 305 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 306 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 307 308 rte_tel_data_start_dict(&response_data); 309 310 rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 0); 311 rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 0); 312 313 rte_tel_data_add_dict_container(&response_data, "dict_0", 314 child_data, 0); 315 rte_tel_data_add_dict_container(&response_data, "dict_1", 316 child_data2, 0); 317 318 return CHECK_OUTPUT("{\"dict_0\":[\"0x888\"],\"dict_1\":[\"0x8888\"]}"); 319 } 320 321 static int 322 test_dict_with_dict_values(void) 323 { 324 struct rte_tel_data *dict_of_dicts = rte_tel_data_alloc(); 325 rte_tel_data_start_dict(dict_of_dicts); 326 327 struct rte_tel_data *child_data = rte_tel_data_alloc(); 328 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 329 330 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 331 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 332 333 rte_tel_data_start_dict(&response_data); 334 335 rte_tel_data_add_array_string(child_data, "aaaa"); 336 rte_tel_data_add_array_string(child_data2, "bbbb"); 337 rte_tel_data_add_dict_container(dict_of_dicts, "dict_0", 338 child_data, 0); 339 rte_tel_data_add_dict_container(dict_of_dicts, "dict_1", 340 child_data2, 0); 341 rte_tel_data_add_dict_container(&response_data, "dict_of_dicts", 342 dict_of_dicts, 0); 343 344 return CHECK_OUTPUT("{\"dict_of_dicts\":{\"dict_0\":[\"aaaa\"],\"dict_1\":[\"bbbb\"]}}"); 345 } 346 347 static int 348 test_array_with_array_string_values(void) 349 { 350 struct rte_tel_data *child_data = rte_tel_data_alloc(); 351 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 352 353 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 354 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 355 356 rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); 357 358 rte_tel_data_add_array_string(child_data, "aaaa"); 359 rte_tel_data_add_array_string(child_data2, "bbbb"); 360 361 rte_tel_data_add_array_container(&response_data, child_data, 0); 362 rte_tel_data_add_array_container(&response_data, child_data2, 0); 363 364 return CHECK_OUTPUT("[[\"aaaa\"],[\"bbbb\"]]"); 365 } 366 367 static int 368 test_array_with_array_uint_hex_values_padding(void) 369 { 370 struct rte_tel_data *child_data = rte_tel_data_alloc(); 371 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 372 373 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 374 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 375 376 rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); 377 378 rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 32); 379 rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 64); 380 381 rte_tel_data_add_array_container(&response_data, child_data, 0); 382 rte_tel_data_add_array_container(&response_data, child_data2, 0); 383 384 return CHECK_OUTPUT("[[\"0x00000888\"],[\"0x0000000000008888\"]]"); 385 } 386 387 388 static int 389 test_array_with_array_uint_hex_values_nopadding(void) 390 { 391 struct rte_tel_data *child_data = rte_tel_data_alloc(); 392 rte_tel_data_start_array(child_data, RTE_TEL_STRING_VAL); 393 394 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 395 rte_tel_data_start_array(child_data2, RTE_TEL_STRING_VAL); 396 397 rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); 398 399 rte_tel_data_add_array_uint_hex(child_data, (uint32_t)0x888, 0); 400 rte_tel_data_add_array_uint_hex(child_data2, (uint64_t)0x8888, 0); 401 402 rte_tel_data_add_array_container(&response_data, child_data, 0); 403 rte_tel_data_add_array_container(&response_data, child_data2, 0); 404 405 return CHECK_OUTPUT("[[\"0x888\"],[\"0x8888\"]]"); 406 } 407 408 static int 409 test_case_array_u64(void) 410 { 411 int i; 412 413 rte_tel_data_start_array(&response_data, RTE_TEL_UINT_VAL); 414 for (i = 0; i < 5; i++) 415 rte_tel_data_add_array_uint(&response_data, i); 416 return CHECK_OUTPUT("[0,1,2,3,4]"); 417 } 418 419 static int 420 test_case_array_uint_hex_padding(void) 421 { 422 rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); 423 rte_tel_data_add_array_uint_hex(&response_data, (uint8_t)0x8, 8); 424 rte_tel_data_add_array_uint_hex(&response_data, (uint16_t)0x88, 16); 425 rte_tel_data_add_array_uint_hex(&response_data, (uint32_t)0x888, 32); 426 rte_tel_data_add_array_uint_hex(&response_data, (uint64_t)0x8888, 64); 427 428 return CHECK_OUTPUT("[\"0x08\",\"0x0088\",\"0x00000888\",\"0x0000000000008888\"]"); 429 } 430 431 static int 432 test_case_array_uint_hex_nopadding(void) 433 { 434 rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); 435 rte_tel_data_add_array_uint_hex(&response_data, (uint8_t)0x8, 0); 436 rte_tel_data_add_array_uint_hex(&response_data, (uint16_t)0x88, 0); 437 rte_tel_data_add_array_uint_hex(&response_data, (uint32_t)0x888, 0); 438 rte_tel_data_add_array_uint_hex(&response_data, (uint64_t)0x8888, 0); 439 440 return CHECK_OUTPUT("[\"0x8\",\"0x88\",\"0x888\",\"0x8888\"]"); 441 } 442 443 static int 444 test_case_add_dict_u64(void) 445 { 446 int i = 0; 447 char name_of_value[8]; 448 449 rte_tel_data_start_dict(&response_data); 450 451 for (i = 0; i < 5; i++) { 452 sprintf(name_of_value, "dict_%d", i); 453 rte_tel_data_add_dict_uint(&response_data, name_of_value, i); 454 } 455 return CHECK_OUTPUT("{\"dict_0\":0,\"dict_1\":1,\"dict_2\":2,\"dict_3\":3,\"dict_4\":4}"); 456 } 457 458 static int 459 test_dict_with_array_u64_values(void) 460 { 461 int i; 462 463 struct rte_tel_data *child_data = rte_tel_data_alloc(); 464 rte_tel_data_start_array(child_data, RTE_TEL_UINT_VAL); 465 466 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 467 rte_tel_data_start_array(child_data2, RTE_TEL_UINT_VAL); 468 469 rte_tel_data_start_dict(&response_data); 470 471 for (i = 0; i < 10; i++) { 472 rte_tel_data_add_array_uint(child_data, i); 473 rte_tel_data_add_array_uint(child_data2, i); 474 } 475 476 rte_tel_data_add_dict_container(&response_data, "dict_0", 477 child_data, 0); 478 rte_tel_data_add_dict_container(&response_data, "dict_1", 479 child_data2, 0); 480 481 return CHECK_OUTPUT("{\"dict_0\":[0,1,2,3,4,5,6,7,8,9],\"dict_1\":[0,1,2,3,4,5,6,7,8,9]}"); 482 } 483 484 static int 485 test_array_with_array_u64_values(void) 486 { 487 int i; 488 489 struct rte_tel_data *child_data = rte_tel_data_alloc(); 490 rte_tel_data_start_array(child_data, RTE_TEL_UINT_VAL); 491 492 struct rte_tel_data *child_data2 = rte_tel_data_alloc(); 493 rte_tel_data_start_array(child_data2, RTE_TEL_UINT_VAL); 494 495 rte_tel_data_start_array(&response_data, RTE_TEL_CONTAINER); 496 497 for (i = 0; i < 5; i++) { 498 rte_tel_data_add_array_uint(child_data, i); 499 rte_tel_data_add_array_uint(child_data2, i); 500 } 501 rte_tel_data_add_array_container(&response_data, child_data, 0); 502 rte_tel_data_add_array_container(&response_data, child_data2, 0); 503 504 return CHECK_OUTPUT("[[0,1,2,3,4],[0,1,2,3,4]]"); 505 } 506 507 static int 508 test_string_char_escaping(void) 509 { 510 rte_tel_data_string(&response_data, "hello,\nworld\n"); 511 return CHECK_OUTPUT("\"hello,\\nworld\\n\""); 512 } 513 514 static int 515 test_array_char_escaping(void) 516 { 517 rte_tel_data_start_array(&response_data, RTE_TEL_STRING_VAL); 518 rte_tel_data_add_array_string(&response_data, "\\escape\r"); 519 rte_tel_data_add_array_string(&response_data, "characters\n"); 520 return CHECK_OUTPUT("[\"\\\\escape\\r\",\"characters\\n\"]"); 521 } 522 523 static int 524 test_dict_char_escaping(void) 525 { 526 rte_tel_data_start_dict(&response_data); 527 rte_tel_data_add_dict_string(&response_data, "name", "escaped\n\tvalue"); 528 return CHECK_OUTPUT("{\"name\":\"escaped\\n\\tvalue\"}"); 529 } 530 531 static int 532 connect_to_socket(void) 533 { 534 char buf[BUF_SIZE]; 535 int sock, bytes; 536 struct sockaddr_un telem_addr; 537 538 sock = socket(AF_UNIX, SOCK_SEQPACKET, 0); 539 if (sock < 0) { 540 printf("\n%s: Error creating socket: %s\n", __func__, 541 strerror(errno)); 542 return -1; 543 } 544 telem_addr.sun_family = AF_UNIX; 545 snprintf(telem_addr.sun_path, sizeof(telem_addr.sun_path), 546 "%s/dpdk_telemetry.%s", rte_eal_get_runtime_dir(), 547 TELEMETRY_VERSION); 548 if (connect(sock, (struct sockaddr *) &telem_addr, 549 sizeof(telem_addr)) < 0) { 550 printf("\n%s: Error connecting to socket: %s\n", __func__, 551 strerror(errno)); 552 close(sock); 553 return -1; 554 } 555 556 bytes = read(sock, buf, sizeof(buf) - 1); 557 if (bytes < 0) { 558 printf("%s: Error with socket read - %s\n", __func__, 559 strerror(errno)); 560 close(sock); 561 return -1; 562 } 563 buf[bytes] = '\0'; 564 printf("\n%s: %s\n", __func__, buf); 565 return sock; 566 } 567 568 static int 569 telemetry_data_autotest(void) 570 { 571 typedef int (*test_case)(void); 572 unsigned int i = 0; 573 574 sock = connect_to_socket(); 575 if (sock <= 0) 576 return -1; 577 578 test_case test_cases[] = { 579 test_null_return, 580 test_simple_string, 581 test_case_array_string, 582 test_case_array_int, test_case_array_u64, 583 test_case_array_uint_hex_padding, 584 test_case_array_uint_hex_nopadding, 585 test_case_add_dict_int, test_case_add_dict_u64, 586 test_case_add_dict_string, 587 test_case_add_dict_uint_hex_padding, 588 test_case_add_dict_uint_hex_nopadding, 589 test_dict_with_array_int_values, 590 test_dict_with_array_u64_values, 591 test_dict_with_array_string_values, 592 test_dict_with_array_uint_hex_values_padding, 593 test_dict_with_array_uint_hex_values_nopadding, 594 test_dict_with_dict_values, 595 test_array_with_array_int_values, 596 test_array_with_array_u64_values, 597 test_array_with_array_string_values, 598 test_array_with_array_uint_hex_values_padding, 599 test_array_with_array_uint_hex_values_nopadding, 600 test_string_char_escaping, 601 test_array_char_escaping, 602 test_dict_char_escaping, 603 }; 604 605 rte_telemetry_register_cmd(REQUEST_CMD, telemetry_test_cb, "Test"); 606 for (i = 0; i < RTE_DIM(test_cases); i++) { 607 memset(&response_data, 0, sizeof(response_data)); 608 if (test_cases[i]() != 0) { 609 close(sock); 610 return -1; 611 } 612 } 613 close(sock); 614 return 0; 615 } 616 #endif /* !RTE_EXEC_ENV_WINDOWS */ 617 618 REGISTER_FAST_TEST(telemetry_data_autotest, true, true, telemetry_data_autotest); 619