bsltest.c (10714B)
1 /* 2 * 3 * This license is set out in https://raw.githubusercontent.com/Broadcom-Network-Switching-Software/OpenBCM/master/Legal/LICENSE file. 4 * 5 * Copyright 2007-2019 Broadcom Inc. All rights reserved. 6 * 7 * Broadcom System Log Test Suites 8 * 9 * This framework can launch test suites to validate BSL functionality 10 * for correctness and backward compatibilty. 11 * 12 * Each test suite is composed of one or more reusable test cases. 13 * 14 * There are two main entries: 15 * 16 * bsltest_run(int) - run a test suite 17 * bsltest_list() - list all test suite 18 */ 19 20 #include <sal/core/libc.h> 21 #include <shared/bsl.h> 22 #include <appl/diag/bslenable.h> 23 #include <appl/diag/bslsink.h> 24 #include <appl/diag/bsltest.h> 25 26 /* Test parameter */ 27 volatile int bsltest_param = 12345678; 28 29 /**************************************** 30 * Helper functions 31 */ 32 33 STATIC void 34 bsltest_sink_prefix_set(bslsink_sink_t *sink, const char *prefix) 35 { 36 sal_strncpy(sink->prefix_format, prefix, BSLSINK_PREFIX_FORMAT_MAX); 37 } 38 39 /**************************************** 40 * Test Cases 41 */ 42 43 STATIC void 44 bsltest_case_basic_macro(int unit) 45 { 46 bsl_printf(">> bsltest_case_basic_macro\n"); 47 48 LOG_FATAL(BSL_LS_APPL_SYMTAB, 49 (BSL_META("LOG_FATAL unit=%d\n"), 50 unit)); 51 LOG_ERROR(BSL_LS_APPL_SYMTAB, 52 (BSL_META("LOG_ERROR unit=%d\n"), 53 unit)); 54 LOG_WARN(BSL_LS_APPL_SYMTAB, 55 (BSL_META("LOG_WARN unit=%d\n"), 56 unit)); 57 LOG_INFO(BSL_LS_APPL_SYMTAB, 58 (BSL_META("LOG_INFO unit=%d\n"), 59 unit)); 60 LOG_VERBOSE(BSL_LS_APPL_SYMTAB, 61 (BSL_META("LOG_VERBOSE unit=%d\n"), 62 unit)); 63 LOG_DEBUG(BSL_LS_APPL_SYMTAB, 64 (BSL_META("LOG_DEBUG unit=%d\n"), 65 unit)); 66 } 67 68 STATIC void 69 bsltest_case_option_macro(void) 70 { 71 int unit = 0; 72 int port = 1; 73 int xtra = 2; 74 75 bsl_printf(">> bsltest_case_option_macro\n"); 76 77 LOG_WARN(BSL_LS_APPL_SYMTAB, 78 (BSL_META("LOG_WARN <nounit> (%d)\n"), 79 bsltest_param)); 80 LOG_WARN(BSL_LS_APPL_SYMTAB, 81 (BSL_META_U(unit, 82 "LOG_WARN unit (%d)\n"), 83 bsltest_param)); 84 LOG_WARN(BSL_LS_APPL_SYMTAB, 85 (BSL_META_UP(unit, port, 86 "LOG_WARN unit/port (%d)\n"), 87 bsltest_param)); 88 LOG_WARN(BSL_LS_APPL_SYMTAB, 89 (BSL_META_UPX(unit, port, xtra, 90 "LOG_WARN unit/port/xtra (%d)\n"), 91 bsltest_param)); 92 } 93 94 STATIC void 95 bsltest_case_incr_single(void) 96 { 97 int idx; 98 99 bsl_log_start(BSL_APPL_SHELL, bslSeverityWarn, BSL_UNIT_UNKNOWN, 100 "[bsl_log_start]"); 101 for (idx = 0; idx < 2; idx++) { 102 bsl_log_add(BSL_APPL_SHELL, bslSeverityWarn, bslSinkIgnore, BSL_UNIT_UNKNOWN, 103 "[bsl_log_add #%d]", idx); 104 } 105 bsl_log_end(BSL_APPL_SHELL, bslSeverityWarn, bslSinkIgnore, BSL_UNIT_UNKNOWN, 106 "[bsl_log_end]\n"); 107 } 108 109 STATIC void 110 bsltest_case_incr_multi(void) 111 { 112 int idx; 113 114 bsl_log_start(BSL_APPL_SHELL, bslSeverityWarn, BSL_UNIT_UNKNOWN, 115 "[bsl_log_start]"); 116 for (idx = 0; idx < 7; idx++) { 117 bsl_log_add(BSL_APPL_SHELL, bslSeverityWarn, bslSinkIgnore, BSL_UNIT_UNKNOWN, 118 "[bsl_log_add #%d]", idx); 119 if ((idx & 0x1) == 1) { 120 bsl_log_add(BSL_APPL_SHELL, bslSeverityWarn, bslSinkIgnore, BSL_UNIT_UNKNOWN, 121 "[newline]\n", idx); 122 } 123 } 124 bsl_log_end(BSL_APPL_SHELL, bslSeverityWarn, bslSinkIgnore, BSL_UNIT_UNKNOWN, 125 "[bsl_log_end]\n"); 126 } 127 128 STATIC void 129 bsltest_case_incr_multi_opt(void) 130 { 131 int idx; 132 133 LOG_WARN(BSL_LS_APPL_SYMTAB, 134 (BSL_META_O(BSL_META_OPT_START | BSL_META_OPT_PFX_NL, 135 "[OPT_START|OPT_PFX_NL]\n"))); 136 for (idx = 0; idx < 7; idx++) { 137 LOG_WARN(BSL_LS_APPL_SYMTAB, 138 (BSL_META_O(0, 139 "[0 #%d]"), idx)); 140 if ((idx & 0x1) == 1) { 141 LOG_WARN(BSL_LS_APPL_SYMTAB, 142 (BSL_META_O(0, 143 "[0] newline\n"))); 144 } 145 } 146 LOG_WARN(BSL_LS_APPL_SYMTAB, 147 (BSL_META_O(BSL_META_OPT_END, 148 "[OPT_END]\n"))); 149 } 150 151 /**************************************** 152 * Test Suites 153 */ 154 155 STATIC void 156 bsltest_test_suite_0(void) 157 { 158 bsltest_case_basic_macro(0); 159 } 160 161 STATIC void 162 bsltest_test_suite_1(void) 163 { 164 } 165 166 STATIC void 167 bsltest_test_suite_2(void) 168 { 169 int sev, cur_sev; 170 171 cur_sev = bslenable_get(bslLayerAppl, bslSourceSymtab); 172 for (sev = 0; sev < bslSeverityCount; sev++) { 173 bslenable_set(bslLayerAppl, bslSourceSymtab, sev); 174 bsltest_case_basic_macro(0); 175 } 176 bslenable_set(bslLayerAppl, bslSourceSymtab, cur_sev); 177 } 178 179 STATIC void 180 bsltest_test_suite_3(void) 181 { 182 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 183 184 if (sink == NULL) { 185 return; 186 } 187 188 sal_memcpy(&cursink, sink, sizeof(cursink)); 189 bsltest_sink_prefix_set(sink, ""); 190 sink->prefix_range.min = bslSeverityOff; 191 sink->prefix_range.max = sink->prefix_range.min; 192 193 bsltest_case_incr_single(); 194 195 sal_memcpy(sink, &cursink, sizeof(cursink)); 196 } 197 198 STATIC void 199 bsltest_test_suite_4(void) 200 { 201 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 202 203 if (sink == NULL) { 204 return; 205 } 206 207 sal_memcpy(&cursink, sink, sizeof(cursink)); 208 bsltest_sink_prefix_set(sink, "PREFIX:"); 209 sink->prefix_range.min = bslSeverityWarn; 210 sink->prefix_range.max = sink->prefix_range.min; 211 212 bsltest_case_incr_single(); 213 214 sal_memcpy(sink, &cursink, sizeof(cursink)); 215 } 216 217 STATIC void 218 bsltest_test_suite_5(void) 219 { 220 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 221 222 if (sink == NULL) { 223 return; 224 } 225 226 sal_memcpy(&cursink, sink, sizeof(cursink)); 227 bsltest_sink_prefix_set(sink, ""); 228 sink->prefix_range.min = bslSeverityOff; 229 sink->prefix_range.max = sink->prefix_range.min; 230 231 bsltest_case_incr_multi(); 232 233 sal_memcpy(sink, &cursink, sizeof(cursink)); 234 } 235 236 STATIC void 237 bsltest_test_suite_6(void) 238 { 239 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 240 241 if (sink == NULL) { 242 return; 243 } 244 245 sal_memcpy(&cursink, sink, sizeof(cursink)); 246 bsltest_sink_prefix_set(sink, "PREFIX:"); 247 sink->prefix_range.min = bslSeverityWarn; 248 sink->prefix_range.max = sink->prefix_range.min; 249 250 bsltest_case_incr_multi(); 251 252 sal_memcpy(sink, &cursink, sizeof(cursink)); 253 } 254 255 STATIC void 256 bsltest_test_suite_7(void) 257 { 258 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 259 260 if (sink == NULL) { 261 return; 262 } 263 264 sal_memcpy(&cursink, sink, sizeof(cursink)); 265 bsltest_sink_prefix_set(sink, "PREFIX:"); 266 sink->prefix_range.min = bslSeverityFatal; 267 sink->prefix_range.max = bslSeverityError; 268 269 bsltest_case_basic_macro(0); 270 271 sal_memcpy(sink, &cursink, sizeof(cursink)); 272 } 273 274 STATIC void 275 bsltest_test_suite_8(void) 276 { 277 bsltest_case_option_macro(); 278 } 279 280 STATIC void 281 bsltest_test_suite_9(void) 282 { 283 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 284 285 if (sink == NULL) { 286 return; 287 } 288 289 sal_memcpy(&cursink, sink, sizeof(cursink)); 290 bsltest_sink_prefix_set(sink, "PREFIX(u=%u p=%p x=%x)"); 291 sink->prefix_range.min = bslSeverityWarn; 292 sink->prefix_range.max = sink->prefix_range.min; 293 294 bsltest_case_option_macro(); 295 296 sal_memcpy(sink, &cursink, sizeof(cursink)); 297 } 298 299 STATIC void 300 bsltest_test_suite_10(void) 301 { 302 bsltest_case_incr_multi_opt(); 303 } 304 305 STATIC void 306 bsltest_test_suite_11(void) 307 { 308 bslsink_sink_t cursink, *sink = bslsink_sink_find_by_id(0); 309 310 if (sink == NULL) { 311 return; 312 } 313 314 sal_memcpy(&cursink, sink, sizeof(cursink)); 315 bsltest_sink_prefix_set(sink, "PREFIX:"); 316 sink->prefix_range.min = bslSeverityWarn; 317 sink->prefix_range.max = sink->prefix_range.min; 318 319 bsltest_case_incr_multi_opt(); 320 321 sal_memcpy(sink, &cursink, sizeof(cursink)); 322 } 323 324 STATIC void 325 bsltest_test_suite_12(void) 326 { 327 bsltest_case_basic_macro(1); 328 } 329 330 STATIC void 331 bsltest_test_suite_13(void) 332 { 333 bsltest_case_basic_macro(BSL_UNIT_UNKNOWN); 334 } 335 336 typedef void (*test_suite_f)(void); 337 338 typedef struct test_suite_s { 339 test_suite_f func; 340 const char *descr; 341 } test_suite_t; 342 343 static test_suite_t test_suites[] = { 344 { bsltest_test_suite_0, "Test all log macros with current settings" }, 345 { bsltest_test_suite_1, NULL }, 346 { bsltest_test_suite_2, "Test all log macros across all severities" }, 347 { bsltest_test_suite_3, "Test incremental logging single line" }, 348 { bsltest_test_suite_4, "Test incremental logging single line with prefix" }, 349 { bsltest_test_suite_5, "Test incremental logging multiple lines" }, 350 { bsltest_test_suite_6, "Test incremental logging multiple lines with prefix" }, 351 { bsltest_test_suite_7, "Test current settings with prefixed Fatal/Error" }, 352 { bsltest_test_suite_8, "Test all log macros with meta options" }, 353 { bsltest_test_suite_9, "Test all log macros with meta options and prefix" }, 354 { bsltest_test_suite_10, "Test option logging multiple lines" }, 355 { bsltest_test_suite_11, "Test option logging multiple lines with prefix" }, 356 { bsltest_test_suite_12, "Test all log functions for unit 1" }, 357 { bsltest_test_suite_13, "Test all log functions for unknown unit (-1)" }, 358 { NULL, NULL } 359 }; 360 361 STATIC void 362 bsltest_run_test_suite(int test_suite_no) 363 { 364 test_suite_t *ts = &test_suites[test_suite_no]; 365 366 if (ts->func != NULL) { 367 bsl_printf("** Starting test suite #%d (%s)\n", 368 test_suite_no, (ts->descr != NULL) ? ts->descr : "<nodesc>"); 369 test_suites[test_suite_no].func(); 370 } else { 371 bsl_printf("** Test suite #%d undefined (skipping)\n", test_suite_no); 372 } 373 } 374 375 /**************************************** 376 * Main Entry 377 */ 378 379 int 380 bsltest_run(int test_suite_no) 381 { 382 int idx; 383 384 if (test_suite_no < 0) { 385 /* Run all */ 386 for (idx = 0; idx < COUNTOF(test_suites); idx++) { 387 if (test_suites[idx].descr == NULL) { 388 continue; 389 } 390 bsltest_run_test_suite(idx); 391 } 392 return 0; 393 } else if (test_suite_no < COUNTOF(test_suites)) { 394 bsltest_run_test_suite(test_suite_no); 395 return 0; 396 } 397 bsl_printf("Invalid test suite #%d\n", test_suite_no); 398 return -1; 399 } 400 401 void 402 bsltest_list(void) 403 { 404 int idx; 405 const char *descr; 406 407 bsl_printf("Available test suites:\n"); 408 for (idx = 0; idx < COUNTOF(test_suites); idx++) { 409 descr = test_suites[idx].descr; 410 if (descr != NULL) { 411 bsl_printf("%-3d: %s\n", idx, descr); 412 } 413 } 414 }