test_logger.c (7743B)
1 /* Copyright (C) 2013-2023, 2025 Vincent Forest (vaplv@free.fr) 2 * 3 * The RSys library is free software: you can redistribute it and/or modify 4 * it under the terms of the GNU General Public License as published 5 * by the Free Software Foundation, either version 3 of the License, or 6 * (at your option) any later version. 7 * 8 * The RSys library is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 * GNU General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public License 14 * along with the RSys library. If not, see <http://www.gnu.org/licenses/>. */ 15 16 #include "logger.h" 17 #include "test_utils.h" 18 19 static void 20 func_stream_out(const char* fmt, void* data) 21 { 22 *(int*)data += 1; 23 CHK(strcmp(fmt, "output") == 0); 24 } 25 26 static void 27 func_stream_out_std(const char* fmt, void* data) 28 { 29 (void)data; 30 printf("%s\n", fmt); 31 } 32 33 static void 34 func_stream_err(const char* fmt, void* data) 35 { 36 *(int*)data += 1; 37 CHK(strcmp(fmt, "error") == 0); 38 } 39 40 static void 41 func_stream_warn(const char* fmt, void* data) 42 { 43 *(int*)data += 1; 44 CHK(strcmp( fmt, "warning" ) == 0); 45 } 46 47 static void 48 test_vprint(struct logger* logger, const char* fmt, ...) 49 { 50 va_list vargs_list; 51 CHK(logger != NULL); 52 CHK(fmt != NULL); 53 54 va_start(vargs_list, fmt); 55 logger_vprint(logger, LOG_OUTPUT, fmt, vargs_list); 56 va_end(vargs_list); 57 } 58 59 int 60 main(int argc, char** argv) 61 { 62 int i = 0; 63 struct mem_allocator allocator_proxy; 64 struct logger logger; 65 int istream_out = 0; 66 int istream_err = 0; 67 int istream_warn = 0; 68 (void)argc, (void)argv; 69 70 mem_init_proxy_allocator( &allocator_proxy, &mem_default_allocator ); 71 72 FOR_EACH( i, 0, 10 ) { 73 logger_print(LOGGER_DEFAULT, LOG_OUTPUT, "Output: %d\n", i); 74 logger_print(LOGGER_DEFAULT, LOG_ERROR, "Error: %.10f\n", (float)i); 75 logger_print(LOGGER_DEFAULT, LOG_WARNING, "Warn: hop%c\n", (char)('a'+i)); 76 } 77 78 logger_init(&allocator_proxy, &logger); 79 logger_print(&logger, LOG_OUTPUT, "out%s", "put"); 80 CHK(istream_out == 0); 81 CHK(istream_err == 0); 82 CHK(istream_warn == 0); 83 84 CHK(logger_has_stream(&logger, LOG_OUTPUT) == 0); 85 CHK(logger_has_stream(&logger, LOG_ERROR) == 0); 86 CHK(logger_has_stream(&logger, LOG_WARNING) == 0); 87 88 logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out); 89 CHK(logger_has_stream(&logger, LOG_OUTPUT) == 1); 90 logger_print(&logger, LOG_OUTPUT, "output"); 91 CHK(istream_out == 1); 92 CHK(istream_err == 0); 93 CHK(istream_warn == 0); 94 95 logger_set_stream(&logger, LOG_ERROR, func_stream_err, &istream_err); 96 logger_set_stream(&logger, LOG_WARNING, func_stream_warn, &istream_warn); 97 CHK(logger_has_stream(&logger, LOG_OUTPUT) == 1); 98 CHK(logger_has_stream(&logger, LOG_ERROR) == 1); 99 CHK(logger_has_stream(&logger, LOG_WARNING) == 1); 100 logger_print(&logger, LOG_OUTPUT, "output"); 101 CHK(istream_out == 2); 102 CHK(istream_err == 0); 103 CHK(istream_warn == 0); 104 logger_print(&logger, LOG_ERROR, "error"); 105 CHK(istream_out == 2); 106 CHK(istream_err == 1); 107 CHK(istream_warn == 0); 108 logger_print(&logger, LOG_WARNING, "war%c%s", 'n', "ing"); 109 CHK(istream_out == 2); 110 CHK(istream_err == 1); 111 CHK(istream_warn == 1); 112 113 logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out); 114 logger_print(&logger, LOG_OUTPUT, "output"); 115 CHK(istream_out == 3); 116 CHK(istream_err == 1); 117 CHK(istream_warn == 1); 118 119 logger_print 120 ( &logger, LOG_OUTPUT, "%c%c%c%c%c%c", 'o', 'u' ,'t', 'p', 'u', 't' ); 121 CHK(istream_out == 4); 122 CHK(istream_err == 1); 123 CHK(istream_warn == 1); 124 logger_print(&logger, LOG_ERROR, "error"); 125 CHK(istream_out == 4); 126 CHK(istream_err == 2); 127 CHK(istream_warn == 1); 128 logger_print(&logger, LOG_WARNING, "warning"); 129 CHK(istream_out == 4); 130 CHK(istream_err == 2); 131 CHK(istream_warn == 2); 132 logger_set_stream(&logger, LOG_ERROR, NULL, NULL); 133 logger_print(&logger, LOG_ERROR, "error"); 134 CHK(istream_out == 4); 135 CHK(istream_err == 2); 136 CHK(istream_warn == 2); 137 138 logger_clear(&logger); 139 CHK(logger_has_stream(&logger, LOG_OUTPUT) == 0); 140 CHK(logger_has_stream(&logger, LOG_ERROR) == 0); 141 CHK(logger_has_stream(&logger, LOG_WARNING) == 0); 142 143 istream_out = istream_err = istream_warn = 0; 144 logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out); 145 logger_set_stream(&logger, LOG_ERROR, func_stream_out, &istream_out); 146 logger_set_stream(&logger, LOG_WARNING, func_stream_out, &istream_out); 147 logger_print(&logger, LOG_OUTPUT, "output"); 148 CHK(istream_out == 1); 149 CHK(istream_err == 0); 150 CHK(istream_warn == 0); 151 logger_print(&logger, LOG_ERROR, "output"); 152 CHK(istream_out == 2); 153 CHK(istream_err == 0); 154 CHK(istream_warn == 0); 155 logger_print(&logger, LOG_WARNING, "output"); 156 CHK(istream_out == 3); 157 CHK(istream_err == 0); 158 CHK(istream_warn == 0); 159 160 logger_set_stream(&logger, LOG_WARNING, NULL, NULL); 161 logger_print(&logger, LOG_WARNING, "output"); 162 CHK(istream_out == 3); 163 CHK(istream_err == 0); 164 CHK(istream_warn == 0); 165 logger_print(&logger, LOG_ERROR, "output"); 166 logger_print(&logger, LOG_OUTPUT, "output"); 167 CHK(istream_out == 5); 168 CHK(istream_err == 0); 169 CHK(istream_warn == 0); 170 171 logger_set_stream(&logger, LOG_OUTPUT, NULL, NULL); 172 logger_set_stream(&logger, LOG_OUTPUT, NULL, NULL); 173 logger_print(&logger, LOG_WARNING, "output"); 174 logger_print(&logger, LOG_OUTPUT, "output"); 175 CHK(istream_out == 5); 176 CHK(istream_err == 0); 177 CHK(istream_warn == 0); 178 logger_print(&logger, LOG_ERROR, "output"); 179 CHK(istream_out == 6); 180 CHK(istream_err == 0); 181 CHK(istream_warn == 0); 182 183 logger_set_stream(&logger, LOG_OUTPUT, func_stream_out, &istream_out); 184 logger_set_stream(&logger, LOG_WARNING, func_stream_out, &istream_out); 185 logger_print(&logger, LOG_OUTPUT, "output"); 186 logger_print(&logger, LOG_ERROR, "output"); 187 logger_print(&logger, LOG_WARNING, "output"); 188 CHK(istream_out == 9); 189 CHK(istream_err == 0); 190 CHK(istream_warn == 0); 191 logger_clear(&logger); 192 logger_print(&logger, LOG_OUTPUT, "output"); 193 logger_print(&logger, LOG_ERROR, "output"); 194 logger_print(&logger, LOG_WARNING, "output"); 195 CHK(istream_out == 9); 196 CHK(istream_err == 0); 197 CHK(istream_warn == 0); 198 199 logger_set_stream(&logger, LOG_OUTPUT, func_stream_out_std, NULL); 200 logger_print 201 (&logger, LOG_OUTPUT, "%s%s%s%s", 202 "Rcvfbqr 1, XARR-QRRC VA GUR QRNQ:\n\ 203 ---------------------------------\n\n", 204 "BAPR LBH ORNG GUR OVT ONQNFFRF NAQ PYRNA BHG GUR ZBBA ONFR LBH'ER FHCCBFRQ GB\n\ 205 JVA, NERA'G LBH? NERA'G LBH? JURER'F LBHE SNG ERJNEQ NAQ GVPXRG UBZR? JUNG\n\ 206 GUR URYY VF GUVF? VG'F ABG FHCCBFRQ GB RAQ GUVF JNL!\n\n", 207 "VG FGVAXF YVXR EBGGRA ZRNG, OHG YBBXF YVXR GUR YBFG QRVZBF ONFR. YBBXF YVXR\n\ 208 LBH'ER FGHPX BA GUR FUBERF BS URYY. GUR BAYL JNL BHG VF GUEBHTU.\n\n", 209 "GB PBAGVAHR GUR QBBZ RKCREVRAPR, CYNL GUR FUBERF BS URYY NAQ VGF NZNMVAT\n\ 210 FRDHRY, VASREAB!\n"); 211 212 test_vprint(&logger, "%s%s%s%s", 213 "Rcvfbqr 2, GUR FUBERF BS URYY:\n\ 214 ------------------------------\n\n", 215 "LBH'IR QBAR VG! GUR UVQRBHF PLORE- QRZBA YBEQ GUNG EHYRQ GUR YBFG QRVZBF ZBBA\n\ 216 ONFR UNF ORRA FYNVA NAQ LBH NER GEVHZCUNAG! OHG ... JURER NER LBH? LBH\n\ 217 PYNZORE GB GUR RQTR BS GUR ZBBA NAQ YBBX QBJA GB FRR GUR NJSHY GEHGU.\n\n", 218 "QRVZBF SYBNGF NOBIR URYY VGFRYS! LBH'IR ARIRE URNEQ BS NALBAR RFPNCVAT SEBZ\n\ 219 URYY, OHG LBH'YY ZNXR GUR ONFGNEQF FBEEL GURL RIRE URNEQ BS LBH! DHVPXYL, LBH\n\ 220 ENCCRY QBJA GB GUR FHESNPR BS URYY.\n\n", 221 "ABJ, VG'F BA GB GUR SVANY PUNCGRE BS QBBZ! -- VASREAB.\n"); 222 223 logger_release(&logger); 224 225 check_memory_allocator(&allocator_proxy); 226 mem_shutdown_proxy_allocator(&allocator_proxy); 227 CHK(mem_allocated_size() == 0); 228 return 0; 229 }