aboutsummaryrefslogtreecommitdiff
path: root/src/util/test_common_logging_runtime_loglevels.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/util/test_common_logging_runtime_loglevels.c')
-rw-r--r--src/util/test_common_logging_runtime_loglevels.c538
1 files changed, 271 insertions, 267 deletions
diff --git a/src/util/test_common_logging_runtime_loglevels.c b/src/util/test_common_logging_runtime_loglevels.c
index 4ba7b544c..b82138492 100644
--- a/src/util/test_common_logging_runtime_loglevels.c
+++ b/src/util/test_common_logging_runtime_loglevels.c
@@ -32,13 +32,15 @@
32 * How much time the child is allowed to waste on skipped log calls, at most. 32 * How much time the child is allowed to waste on skipped log calls, at most.
33 * Raspberry Pi takes 113 microseconds tops, this is 3x that value. 33 * Raspberry Pi takes 113 microseconds tops, this is 3x that value.
34 */ 34 */
35#define MAX_SKIP_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 400).rel_value_us 35#define MAX_SKIP_DELAY GNUNET_TIME_relative_multiply ( \
36 GNUNET_TIME_UNIT_MICROSECONDS, 400).rel_value_us
36 37
37/** 38/**
38 * How much time non-skipped log call should take, at least. 39 * How much time non-skipped log call should take, at least.
39 * Keep in sync with the value in the dummy! 40 * Keep in sync with the value in the dummy!
40 */ 41 */
41#define OUTPUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us 42#define OUTPUT_DELAY GNUNET_TIME_relative_multiply ( \
43 GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us
42 44
43static int ok; 45static int ok;
44 46
@@ -49,56 +51,56 @@ static struct GNUNET_OS_Process *proc;
49/* Pipe to read from started processes stdout (on read end) */ 51/* Pipe to read from started processes stdout (on read end) */
50static struct GNUNET_DISK_PipeHandle *pipe_stdout; 52static struct GNUNET_DISK_PipeHandle *pipe_stdout;
51 53
52static struct GNUNET_SCHEDULER_Task * die_task; 54static struct GNUNET_SCHEDULER_Task *die_task;
53 55
54static struct GNUNET_SCHEDULER_Task * read_task; 56static struct GNUNET_SCHEDULER_Task *read_task;
55 57
56static void 58static void
57runone(void); 59runone (void);
58 60
59 61
60static void 62static void
61end_task(void *cls) 63end_task (void *cls)
62{ 64{
63 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase, 65 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase,
64 ok); 66 ok);
65 if (NULL != proc) 67 if (NULL != proc)
68 {
69 if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG))
66 { 70 {
67 if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) 71 GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill");
68 {
69 GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "kill");
70 }
71 GNUNET_OS_process_wait(proc);
72 GNUNET_OS_process_destroy(proc);
73 proc = NULL;
74 } 72 }
73 GNUNET_OS_process_wait (proc);
74 GNUNET_OS_process_destroy (proc);
75 proc = NULL;
76 }
75 if (NULL != read_task) 77 if (NULL != read_task)
76 { 78 {
77 GNUNET_SCHEDULER_cancel(read_task); 79 GNUNET_SCHEDULER_cancel (read_task);
78 read_task = NULL; 80 read_task = NULL;
79 } 81 }
80 GNUNET_DISK_pipe_close(pipe_stdout); 82 GNUNET_DISK_pipe_close (pipe_stdout);
81 if (ok == 1) 83 if (ok == 1)
84 {
85 if (phase < 9)
82 { 86 {
83 if (phase < 9) 87 phase += 1;
84 { 88 runone ();
85 phase += 1;
86 runone();
87 }
88 else
89 ok = 0;
90 } 89 }
90 else
91 ok = 0;
92 }
91 else 93 else
92 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "failing\n"); 94 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "failing\n");
93} 95}
94 96
95 97
96static char * 98static char *
97read_output_line(int phase_from1, int phase_to1, int phase_from2, 99read_output_line (int phase_from1, int phase_to1, int phase_from2,
98 int phase_to2, char c, const char *expect_level, 100 int phase_to2, char c, const char *expect_level,
99 long delay_morethan, long delay_lessthan, int phase, 101 long delay_morethan, long delay_lessthan, int phase,
100 char *p, 102 char *p,
101 int *len, long *delay, char level[8]) 103 int *len, long *delay, char level[8])
102{ 104{
103 char *r = p; 105 char *r = p;
104 char t[7]; 106 char t[7];
@@ -111,83 +113,84 @@ read_output_line(int phase_from1, int phase_to1, int phase_from2,
111 j = 0; 113 j = 0;
112 int stage = 0; 114 int stage = 0;
113 115
114 if (!(phase >= phase_from1 && phase <= phase_to1) && 116 if (! ((phase >= phase_from1)&&(phase <= phase_to1)) &&
115 !(phase >= phase_from2 && phase <= phase_to2)) 117 ! ((phase >= phase_from2)&&(phase <= phase_to2)))
116 return p; 118 return p;
117#if 0 119#if 0
118 GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, 120 GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
119 "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p); 121 "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p);
120#endif 122#endif
121 for (i = 0; i < *len && !stop; i++) 123 for (i = 0; i < *len && ! stop; i++)
124 {
125 switch (stage)
122 { 126 {
123 switch (stage) 127 case 0: /* read first char */
124 { 128 if (r[i] != c)
125 case 0: /* read first char */ 129 {
126 if (r[i] != c) 130 GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c,
127 { 131 r[i]);
128 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c, 132 GNUNET_break (0);
129 r[i]); 133 return NULL;
130 GNUNET_break(0); 134 }
131 return NULL; 135 stage += 1;
132 } 136 break;
133 stage += 1; 137
134 break; 138 case 1: /* read at most 7 char-long error level string, finished by ' ' */
135 139 if (r[i] == ' ')
136 case 1: /* read at most 7 char-long error level string, finished by ' ' */ 140 {
137 if (r[i] == ' ') 141 level[j] = '\0';
138 { 142 stage += 1;
139 level[j] = '\0'; 143 j = 0;
140 stage += 1; 144 }
141 j = 0; 145 else if (i == 8)
142 } 146 {
143 else if (i == 8) 147 GNUNET_break (0);
144 { 148 ok = 2;
145 GNUNET_break(0); 149 return NULL;
146 ok = 2; 150 }
147 return NULL; 151 else
148 } 152 level[j++] = r[i];
149 else 153 break;
150 level[j++] = r[i]; 154
151 break; 155 case 2: /* read the delay, finished by '\n' */
152 156 t[j++] = r[i];
153 case 2: /* read the delay, finished by '\n' */ 157 if (r[i] == '\n')
154 t[j++] = r[i]; 158 {
155 if (r[i] == '\n') 159 t[j - 1] = '\0';
156 { 160 *delay = strtol (t, NULL, 10);
157 t[j - 1] = '\0'; 161 stop = 1;
158 *delay = strtol(t, NULL, 10); 162 }
159 stop = 1; 163 break;
160 }
161 break;
162 }
163 } 164 }
164 level_matches = (strcmp(expect_level, level) == 0); 165 }
166 level_matches = (strcmp (expect_level, level) == 0);
165 delay_is_sane = (*delay >= 0) && (*delay <= 1000000); 167 delay_is_sane = (*delay >= 0) && (*delay <= 1000000);
166 delay_is_a_dummy = (c == 'L'); 168 delay_is_a_dummy = (c == 'L');
167 /* Delay must be either less than 'lessthan' (log call is skipped) 169 /* Delay must be either less than 'lessthan' (log call is skipped)
168 * or more than 'morethan' (log call is not skipped) 170 * or more than 'morethan' (log call is not skipped)
169 */ 171 */
170 delay_outside_of_range = ((*delay < delay_lessthan) || (*delay >= delay_morethan)); 172 delay_outside_of_range = ((*delay < delay_lessthan) || (*delay >=
173 delay_morethan));
171 if (delay_is_a_dummy) 174 if (delay_is_a_dummy)
172 delay_outside_of_range = 1; 175 delay_outside_of_range = 1;
173 176
174 if (!stop) 177 if (! stop)
175 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 178 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
176 "Wrong log format?\n"); 179 "Wrong log format?\n");
177 if (!level_matches) 180 if (! level_matches)
178 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 181 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
179 "Wrong log level\n"); 182 "Wrong log level\n");
180 if (!delay_is_sane) 183 if (! delay_is_sane)
181 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 184 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
182 "Delay %ld is insane\n", 185 "Delay %ld is insane\n",
183 *delay); 186 *delay);
184 if (!delay_outside_of_range) 187 if (! delay_outside_of_range)
185 GNUNET_log(GNUNET_ERROR_TYPE_ERROR, 188 GNUNET_log (GNUNET_ERROR_TYPE_ERROR,
186 "Delay %ld is not outside of range (%ld ; %ld)\n", 189 "Delay %ld is not outside of range (%ld ; %ld)\n",
187 *delay, 190 *delay,
188 delay_lessthan, 191 delay_lessthan,
189 delay_morethan); 192 delay_morethan);
190 if (!stop || !level_matches || !delay_is_sane || !delay_outside_of_range) 193 if (! stop || ! level_matches || ! delay_is_sane || ! delay_outside_of_range)
191 return NULL; 194 return NULL;
192 *len = *len - i; 195 *len = *len - i;
193 return &r[i]; 196 return &r[i];
@@ -203,7 +206,7 @@ read_output_line(int phase_from1, int phase_to1, int phase_from2,
203 */ 206 */
204#define LOG_MAX_LINE_LENGTH (17) 207#define LOG_MAX_LINE_LENGTH (17)
205 208
206#define LOG_BUFFER_SIZE LOG_MAX_NUM_LINES * LOG_MAX_LINE_LENGTH 209#define LOG_BUFFER_SIZE LOG_MAX_NUM_LINES *LOG_MAX_LINE_LENGTH
207 210
208static char buf[LOG_BUFFER_SIZE]; 211static char buf[LOG_BUFFER_SIZE];
209 212
@@ -213,7 +216,7 @@ static int bytes;
213 216
214 217
215static void 218static void
216read_call(void *cls) 219read_call (void *cls)
217{ 220{
218 const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls; 221 const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls;
219 char level[8]; 222 char level[8];
@@ -222,24 +225,24 @@ read_call(void *cls)
222 int rd; 225 int rd;
223 226
224 read_task = NULL; 227 read_task = NULL;
225 rd = GNUNET_DISK_file_read(stdout_read_handle, buf_ptr, 228 rd = GNUNET_DISK_file_read (stdout_read_handle, buf_ptr,
226 sizeof(buf) - bytes); 229 sizeof(buf) - bytes);
227 if (rd > 0) 230 if (rd > 0)
228 { 231 {
229 buf_ptr += rd; 232 buf_ptr += rd;
230 bytes += rd; 233 bytes += rd;
231#if VERBOSE 234#if VERBOSE
232 fprintf(stderr, "got %d bytes, reading more\n", rd); 235 fprintf (stderr, "got %d bytes, reading more\n", rd);
233#endif 236#endif
234 read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, 237 read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
235 stdout_read_handle, 238 stdout_read_handle,
236 &read_call, 239 &read_call,
237 (void*)stdout_read_handle); 240 (void*) stdout_read_handle);
238 return; 241 return;
239 } 242 }
240 243
241#if VERBOSE 244#if VERBOSE
242 fprintf(stderr, "bytes is %d:%s\n", bytes, buf); 245 fprintf (stderr, "bytes is %d:%s\n", bytes, buf);
243#endif 246#endif
244 247
245 /* +------CHILD OUTPUT-- 248 /* +------CHILD OUTPUT--
@@ -259,193 +262,194 @@ read_call(void *cls)
259 */ 262 */
260 char *p = buf; 263 char *p = buf;
261 264
262 if (bytes == LOG_BUFFER_SIZE || 265 if ((bytes == LOG_BUFFER_SIZE)||
263 !(p = 266 ! (p =
264 read_output_line(0, 3, 4, 9, 'L', "ERROR", -1, 267 read_output_line (0, 3, 4, 9, 'L', "ERROR", -1,
265 1, phase, p, 268 1, phase, p,
266 &bytes, &delay, level)) || 269 &bytes, &delay, level)) ||
267 !(p = 270 ! (p =
268 read_output_line(0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY, 271 read_output_line (0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY,
269 MAX_SKIP_DELAY, phase, p, 272 MAX_SKIP_DELAY, phase, p,
270 &bytes, &delays[0], level)) || 273 &bytes, &delays[0], level)) ||
271 !(p = 274 ! (p =
272 read_output_line(1, 3, 5, 9, 'L', "WARNING", -1, 275 read_output_line (1, 3, 5, 9, 'L', "WARNING", -1,
273 1, phase, p, 276 1, phase, p,
274 &bytes, &delay, level)) || 277 &bytes, &delay, level)) ||
275 !(p = 278 ! (p =
276 read_output_line(0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY, 279 read_output_line (0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY,
277 MAX_SKIP_DELAY, phase, p, 280 MAX_SKIP_DELAY, phase, p,
278 &bytes, &delays[1], level)) || 281 &bytes, &delays[1], level)) ||
279 !(p = 282 ! (p =
280 read_output_line(2, 3, 6, 7, 'L', "INFO", -1, 283 read_output_line (2, 3, 6, 7, 'L', "INFO", -1,
281 1, phase, p, 284 1, phase, p,
282 &bytes, &delay, level)) || 285 &bytes, &delay, level)) ||
283 !(p = 286 ! (p =
284 read_output_line(0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY, 287 read_output_line (0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY,
285 MAX_SKIP_DELAY, phase, p, 288 MAX_SKIP_DELAY, phase, p,
286 &bytes, &delays[2], level)) || 289 &bytes, &delays[2], level)) ||
287 !(p = 290 ! (p =
288 read_output_line(3, 3, 7, 7, 'L', "DEBUG", -1, 291 read_output_line (3, 3, 7, 7, 'L', "DEBUG", -1,
289 1, phase, p, 292 1, phase, p,
290 &bytes, &delay, level)) || 293 &bytes, &delay, level)) ||
291 !(p = 294 ! (p =
292 read_output_line(0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY, 295 read_output_line (0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY,
293 MAX_SKIP_DELAY, phase, p, 296 MAX_SKIP_DELAY, phase, p,
294 &bytes, &delays[3], level)) || 297 &bytes, &delays[3], level)) ||
295 !(p = 298 ! (p =
296 read_output_line(0, 3, 4, 9, 'L', "ERROR", -1, 299 read_output_line (0, 3, 4, 9, 'L', "ERROR", -1,
297 1, phase, p, 300 1, phase, p,
298 &bytes, &delay, level)) || 301 &bytes, &delay, level)) ||
299 !(p = 302 ! (p =
300 read_output_line(0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY, 303 read_output_line (0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY,
301 MAX_SKIP_DELAY, phase, p, 304 MAX_SKIP_DELAY, phase, p,
302 &bytes, &delays[4], level)) || 305 &bytes, &delays[4], level)) ||
303 !(p = 306 ! (p =
304 read_output_line(0, 3, 5, 9, 'L', "WARNING", -1, 307 read_output_line (0, 3, 5, 9, 'L', "WARNING", -1,
305 1, phase, p, 308 1, phase, p,
306 &bytes, &delay, level)) || 309 &bytes, &delay, level)) ||
307 !(p = 310 ! (p =
308 read_output_line(0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY, 311 read_output_line (0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY,
309 MAX_SKIP_DELAY, phase, p, 312 MAX_SKIP_DELAY, phase, p,
310 &bytes, &delays[5], level)) || 313 &bytes, &delays[5], level)) ||
311 !(p = 314 ! (p =
312 read_output_line(-1, -1, 6, 7, 'L', "INFO", -1, 315 read_output_line (-1, -1, 6, 7, 'L', "INFO", -1,
313 1, phase, p, 316 1, phase, p,
314 &bytes, &delay, level)) || 317 &bytes, &delay, level)) ||
315 !(p = 318 ! (p =
316 read_output_line(0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY, 319 read_output_line (0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY,
317 MAX_SKIP_DELAY, phase, p, 320 MAX_SKIP_DELAY, phase, p,
318 &bytes, &delays[6], level)) || 321 &bytes, &delays[6], level)) ||
319 !(p = 322 ! (p =
320 read_output_line(-1, -1, 7, 7, 'L', "DEBUG", -1, 323 read_output_line (-1, -1, 7, 7, 'L', "DEBUG", -1,
321 1, phase, p, 324 1, phase, p,
322 &bytes, &delay, level)) || 325 &bytes, &delay, level)) ||
323 !(p = 326 ! (p =
324 read_output_line(0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY, 327 read_output_line (0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY,
325 MAX_SKIP_DELAY, phase, p, 328 MAX_SKIP_DELAY, phase, p,
326 &bytes, &delays[7], level))) 329 &bytes, &delays[7], level)))
327 { 330 {
328 if (bytes == LOG_BUFFER_SIZE) 331 if (bytes == LOG_BUFFER_SIZE)
329 fprintf(stderr, "%s", "Ran out of buffer space!\n"); 332 fprintf (stderr, "%s", "Ran out of buffer space!\n");
330 GNUNET_break(0); 333 GNUNET_break (0);
331 ok = 2; 334 ok = 2;
332 GNUNET_SCHEDULER_cancel(die_task); 335 GNUNET_SCHEDULER_cancel (die_task);
333 GNUNET_SCHEDULER_add_now(&end_task, NULL); 336 GNUNET_SCHEDULER_add_now (&end_task, NULL);
334 return; 337 return;
335 } 338 }
336 339
337 GNUNET_SCHEDULER_cancel(die_task); 340 GNUNET_SCHEDULER_cancel (die_task);
338 GNUNET_SCHEDULER_add_now(&end_task, NULL); 341 GNUNET_SCHEDULER_add_now (&end_task, NULL);
339} 342}
340 343
341 344
342static void 345static void
343runone() 346runone ()
344{ 347{
345 const struct GNUNET_DISK_FileHandle *stdout_read_handle; 348 const struct GNUNET_DISK_FileHandle *stdout_read_handle;
346 349
347 pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); 350 pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO,
351 GNUNET_YES);
348 352
349 if (pipe_stdout == NULL) 353 if (pipe_stdout == NULL)
350 { 354 {
351 GNUNET_break(0); 355 GNUNET_break (0);
352 ok = 2; 356 ok = 2;
353 return; 357 return;
354 } 358 }
355 359
356 putenv("GNUNET_LOG="); 360 putenv ("GNUNET_LOG=");
357 putenv("GNUNET_FORCE_LOG="); 361 putenv ("GNUNET_FORCE_LOG=");
358 putenv("GNUNET_FORCE_LOGFILE="); 362 putenv ("GNUNET_FORCE_LOGFILE=");
359 switch (phase) 363 switch (phase)
360 { 364 {
361 case 0: 365 case 0:
362 putenv("GNUNET_LOG=;;;;ERROR"); 366 putenv ("GNUNET_LOG=;;;;ERROR");
363 break; 367 break;
364 368
365 case 1: 369 case 1:
366 putenv("GNUNET_LOG=;;;;WARNING"); 370 putenv ("GNUNET_LOG=;;;;WARNING");
367 break; 371 break;
368 372
369 case 2: 373 case 2:
370 putenv("GNUNET_LOG=;;;;INFO"); 374 putenv ("GNUNET_LOG=;;;;INFO");
371 break; 375 break;
372 376
373 case 3: 377 case 3:
374 putenv("GNUNET_LOG=;;;;DEBUG"); 378 putenv ("GNUNET_LOG=;;;;DEBUG");
375 break; 379 break;
376 380
377 case 4: 381 case 4:
378 putenv("GNUNET_FORCE_LOG=;;;;ERROR"); 382 putenv ("GNUNET_FORCE_LOG=;;;;ERROR");
379 break; 383 break;
380 384
381 case 5: 385 case 5:
382 putenv("GNUNET_FORCE_LOG=;;;;WARNING"); 386 putenv ("GNUNET_FORCE_LOG=;;;;WARNING");
383 break; 387 break;
384 388
385 case 6: 389 case 6:
386 putenv("GNUNET_FORCE_LOG=;;;;INFO"); 390 putenv ("GNUNET_FORCE_LOG=;;;;INFO");
387 break; 391 break;
388 392
389 case 7: 393 case 7:
390 putenv("GNUNET_FORCE_LOG=;;;;DEBUG"); 394 putenv ("GNUNET_FORCE_LOG=;;;;DEBUG");
391 break; 395 break;
392 396
393 case 8: 397 case 8:
394 putenv("GNUNET_LOG=blah;;;;ERROR"); 398 putenv ("GNUNET_LOG=blah;;;;ERROR");
395 break; 399 break;
396 400
397 case 9: 401 case 9:
398 putenv("GNUNET_FORCE_LOG=blah;;;;ERROR"); 402 putenv ("GNUNET_FORCE_LOG=blah;;;;ERROR");
399 break; 403 break;
400 } 404 }
401 405
402 proc = GNUNET_OS_start_process(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, 406 proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR,
403 NULL, pipe_stdout, NULL, 407 NULL, pipe_stdout, NULL,
404 "./test_common_logging_dummy", 408 "./test_common_logging_dummy",
405 "test_common_logging_dummy", NULL); 409 "test_common_logging_dummy", NULL);
406 GNUNET_assert(NULL != proc); 410 GNUNET_assert (NULL != proc);
407 putenv("GNUNET_FORCE_LOG="); 411 putenv ("GNUNET_FORCE_LOG=");
408 putenv("GNUNET_LOG="); 412 putenv ("GNUNET_LOG=");
409 413
410 /* Close the write end of the read pipe */ 414 /* Close the write end of the read pipe */
411 GNUNET_DISK_pipe_close_end(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE); 415 GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE);
412 416
413 stdout_read_handle = 417 stdout_read_handle =
414 GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_READ); 418 GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ);
415 419
416 die_task = 420 die_task =
417 GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply 421 GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply
418 (GNUNET_TIME_UNIT_SECONDS, 10), 422 (GNUNET_TIME_UNIT_SECONDS, 10),
419 &end_task, 423 &end_task,
420 NULL); 424 NULL);
421 425
422 bytes = 0; 426 bytes = 0;
423 buf_ptr = buf; 427 buf_ptr = buf;
424 memset(&buf, 0, sizeof(buf)); 428 memset (&buf, 0, sizeof(buf));
425 429
426 read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, 430 read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL,
427 stdout_read_handle, 431 stdout_read_handle,
428 &read_call, 432 &read_call,
429 (void*)stdout_read_handle); 433 (void*) stdout_read_handle);
430} 434}
431 435
432 436
433static void 437static void
434task(void *cls) 438task (void *cls)
435{ 439{
436 phase = 0; 440 phase = 0;
437 runone(); 441 runone ();
438} 442}
439 443
440 444
441int 445int
442main(int argc, char *argv[]) 446main (int argc, char *argv[])
443{ 447{
444 GNUNET_log_setup("test-common-logging-runtime-loglevels", 448 GNUNET_log_setup ("test-common-logging-runtime-loglevels",
445 "WARNING", 449 "WARNING",
446 NULL); 450 NULL);
447 ok = 1; 451 ok = 1;
448 GNUNET_SCHEDULER_run(&task, &ok); 452 GNUNET_SCHEDULER_run (&task, &ok);
449 return ok; 453 return ok;
450} 454}
451 455
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-23 21:24:32 +0000