diff options
Diffstat (limited to 'src/util/test_common_logging_runtime_loglevels.c')
-rw-r--r-- | src/util/test_common_logging_runtime_loglevels.c | 493 |
1 files changed, 252 insertions, 241 deletions
diff --git a/src/util/test_common_logging_runtime_loglevels.c b/src/util/test_common_logging_runtime_loglevels.c index 8da808760..f46776c8f 100644 --- a/src/util/test_common_logging_runtime_loglevels.c +++ b/src/util/test_common_logging_runtime_loglevels.c | |||
@@ -11,12 +11,12 @@ | |||
11 | WITHOUT ANY WARRANTY; without even the implied warranty of | 11 | WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | 12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Affero General Public License for more details. | 13 | Affero General Public License for more details. |
14 | 14 | ||
15 | You should have received a copy of the GNU Affero General Public License | 15 | You should have received a copy of the GNU Affero General Public License |
16 | along with this program. If not, see <http://www.gnu.org/licenses/>. | 16 | along with this program. If not, see <http://www.gnu.org/licenses/>. |
17 | 17 | ||
18 | SPDX-License-Identifier: AGPL3.0-or-later | 18 | SPDX-License-Identifier: AGPL3.0-or-later |
19 | */ | 19 | */ |
20 | 20 | ||
21 | /** | 21 | /** |
22 | * @file util/test_common_logging_runtime_loglevels.c | 22 | * @file util/test_common_logging_runtime_loglevels.c |
@@ -32,13 +32,13 @@ | |||
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(GNUNET_TIME_UNIT_MICROSECONDS, 400).rel_value_us |
36 | 36 | ||
37 | /** | 37 | /** |
38 | * How much time non-skipped log call should take, at least. | 38 | * How much time non-skipped log call should take, at least. |
39 | * Keep in sync with the value in the dummy! | 39 | * Keep in sync with the value in the dummy! |
40 | */ | 40 | */ |
41 | #define OUTPUT_DELAY GNUNET_TIME_relative_multiply (GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us | 41 | #define OUTPUT_DELAY GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_MICROSECONDS, 1000).rel_value_us |
42 | 42 | ||
43 | static int ok; | 43 | static int ok; |
44 | 44 | ||
@@ -54,51 +54,51 @@ static struct GNUNET_SCHEDULER_Task * die_task; | |||
54 | static struct GNUNET_SCHEDULER_Task * read_task; | 54 | static struct GNUNET_SCHEDULER_Task * read_task; |
55 | 55 | ||
56 | static void | 56 | static void |
57 | runone (void); | 57 | runone(void); |
58 | 58 | ||
59 | 59 | ||
60 | static void | 60 | static void |
61 | end_task (void *cls) | 61 | end_task(void *cls) |
62 | { | 62 | { |
63 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase, | 63 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, "Ending phase %d, ok is %d\n", phase, |
64 | ok); | 64 | ok); |
65 | if (NULL != proc) | 65 | if (NULL != proc) |
66 | { | ||
67 | if (0 != GNUNET_OS_process_kill (proc, GNUNET_TERM_SIG)) | ||
68 | { | 66 | { |
69 | GNUNET_log_strerror (GNUNET_ERROR_TYPE_WARNING, "kill"); | 67 | if (0 != GNUNET_OS_process_kill(proc, GNUNET_TERM_SIG)) |
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; | ||
70 | } | 74 | } |
71 | GNUNET_OS_process_wait (proc); | ||
72 | GNUNET_OS_process_destroy (proc); | ||
73 | proc = NULL; | ||
74 | } | ||
75 | if (NULL != read_task) | 75 | if (NULL != read_task) |
76 | { | 76 | { |
77 | GNUNET_SCHEDULER_cancel (read_task); | 77 | GNUNET_SCHEDULER_cancel(read_task); |
78 | read_task = NULL; | 78 | read_task = NULL; |
79 | } | 79 | } |
80 | GNUNET_DISK_pipe_close (pipe_stdout); | 80 | GNUNET_DISK_pipe_close(pipe_stdout); |
81 | if (ok == 1) | 81 | if (ok == 1) |
82 | { | ||
83 | if (phase < 9) | ||
84 | { | 82 | { |
85 | phase += 1; | 83 | if (phase < 9) |
86 | runone (); | 84 | { |
85 | phase += 1; | ||
86 | runone(); | ||
87 | } | ||
88 | else | ||
89 | ok = 0; | ||
87 | } | 90 | } |
88 | else | ||
89 | ok = 0; | ||
90 | } | ||
91 | else | 91 | else |
92 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "failing\n"); | 92 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "failing\n"); |
93 | } | 93 | } |
94 | 94 | ||
95 | 95 | ||
96 | static char * | 96 | static char * |
97 | read_output_line (int phase_from1, int phase_to1, int phase_from2, | 97 | read_output_line(int phase_from1, int phase_to1, int phase_from2, |
98 | int phase_to2, char c, const char *expect_level, | 98 | int phase_to2, char c, const char *expect_level, |
99 | long delay_morethan, long delay_lessthan, int phase, | 99 | long delay_morethan, long delay_lessthan, int phase, |
100 | char *p, | 100 | char *p, |
101 | int *len, long *delay, char level[8]) | 101 | int *len, long *delay, char level[8]) |
102 | { | 102 | { |
103 | char *r = p; | 103 | char *r = p; |
104 | char t[7]; | 104 | char t[7]; |
@@ -115,61 +115,63 @@ read_output_line (int phase_from1, int phase_to1, int phase_from2, | |||
115 | !(phase >= phase_from2 && phase <= phase_to2)) | 115 | !(phase >= phase_from2 && phase <= phase_to2)) |
116 | return p; | 116 | return p; |
117 | #if 0 | 117 | #if 0 |
118 | GNUNET_log (GNUNET_ERROR_TYPE_DEBUG, | 118 | GNUNET_log(GNUNET_ERROR_TYPE_DEBUG, |
119 | "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p); | 119 | "Trying to match '%c%s \\d\\r\\n' on %s\n", c, expect_level, p); |
120 | #endif | 120 | #endif |
121 | for (i = 0; i < *len && !stop; i++) | 121 | for (i = 0; i < *len && !stop; i++) |
122 | { | ||
123 | switch (stage) | ||
124 | { | 122 | { |
125 | case 0: /* read first char */ | 123 | switch (stage) |
126 | if (r[i] != c) | 124 | { |
127 | { | 125 | case 0: /* read first char */ |
128 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c, | 126 | if (r[i] != c) |
129 | r[i]); | 127 | { |
130 | GNUNET_break (0); | 128 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, "Expected '%c', but got '%c'\n", c, |
131 | return NULL; | 129 | r[i]); |
132 | } | 130 | GNUNET_break(0); |
133 | stage += 1; | 131 | return NULL; |
134 | break; | 132 | } |
135 | case 1: /* read at most 7 char-long error level string, finished by ' ' */ | 133 | stage += 1; |
136 | if (r[i] == ' ') | 134 | break; |
137 | { | 135 | |
138 | level[j] = '\0'; | 136 | case 1: /* read at most 7 char-long error level string, finished by ' ' */ |
139 | stage += 1; | 137 | if (r[i] == ' ') |
140 | j = 0; | 138 | { |
141 | } | 139 | level[j] = '\0'; |
142 | else if (i == 8) | 140 | stage += 1; |
143 | { | 141 | j = 0; |
144 | GNUNET_break (0); | 142 | } |
145 | ok = 2; | 143 | else if (i == 8) |
146 | return NULL; | 144 | { |
147 | } | 145 | GNUNET_break(0); |
148 | else | 146 | ok = 2; |
149 | level[j++] = r[i]; | 147 | return NULL; |
150 | break; | 148 | } |
151 | case 2: /* read the delay, finished by '\n' */ | 149 | else |
152 | t[j++] = r[i]; | 150 | level[j++] = r[i]; |
151 | break; | ||
152 | |||
153 | case 2: /* read the delay, finished by '\n' */ | ||
154 | t[j++] = r[i]; | ||
153 | #if WINDOWS | 155 | #if WINDOWS |
154 | if (r[i] == '\r' && r[i + 1] == '\n') | 156 | if (r[i] == '\r' && r[i + 1] == '\n') |
155 | { | 157 | { |
156 | i += 1; | 158 | i += 1; |
157 | t[j - 1] = '\0'; | 159 | t[j - 1] = '\0'; |
158 | *delay = strtol (t, NULL, 10); | 160 | *delay = strtol(t, NULL, 10); |
159 | stop = 1; | 161 | stop = 1; |
160 | } | 162 | } |
161 | #else | 163 | #else |
162 | if (r[i] == '\n') | 164 | if (r[i] == '\n') |
163 | { | 165 | { |
164 | t[j - 1] = '\0'; | 166 | t[j - 1] = '\0'; |
165 | *delay = strtol (t, NULL, 10); | 167 | *delay = strtol(t, NULL, 10); |
166 | stop = 1; | 168 | stop = 1; |
167 | } | 169 | } |
168 | #endif | 170 | #endif |
169 | break; | 171 | break; |
172 | } | ||
170 | } | 173 | } |
171 | } | 174 | level_matches = (strcmp(expect_level, level) == 0); |
172 | level_matches = (strcmp (expect_level, level) == 0); | ||
173 | delay_is_sane = (*delay >= 0) && (*delay <= 1000000); | 175 | delay_is_sane = (*delay >= 0) && (*delay <= 1000000); |
174 | delay_is_a_dummy = (c == 'L'); | 176 | delay_is_a_dummy = (c == 'L'); |
175 | /* Delay must be either less than 'lessthan' (log call is skipped) | 177 | /* Delay must be either less than 'lessthan' (log call is skipped) |
@@ -179,22 +181,22 @@ read_output_line (int phase_from1, int phase_to1, int phase_from2, | |||
179 | if (delay_is_a_dummy) | 181 | if (delay_is_a_dummy) |
180 | delay_outside_of_range = 1; | 182 | delay_outside_of_range = 1; |
181 | 183 | ||
182 | if (! stop) | 184 | if (!stop) |
183 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 185 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
184 | "Wrong log format?\n"); | 186 | "Wrong log format?\n"); |
185 | if (! level_matches) | 187 | if (!level_matches) |
186 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 188 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
187 | "Wrong log level\n"); | 189 | "Wrong log level\n"); |
188 | if (! delay_is_sane) | 190 | if (!delay_is_sane) |
189 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 191 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
190 | "Delay %ld is insane\n", | 192 | "Delay %ld is insane\n", |
191 | *delay); | 193 | *delay); |
192 | if (! delay_outside_of_range) | 194 | if (!delay_outside_of_range) |
193 | GNUNET_log (GNUNET_ERROR_TYPE_ERROR, | 195 | GNUNET_log(GNUNET_ERROR_TYPE_ERROR, |
194 | "Delay %ld is not outside of range (%ld ; %ld)\n", | 196 | "Delay %ld is not outside of range (%ld ; %ld)\n", |
195 | *delay, | 197 | *delay, |
196 | delay_lessthan, | 198 | delay_lessthan, |
197 | delay_morethan); | 199 | delay_morethan); |
198 | if (!stop || !level_matches || !delay_is_sane || !delay_outside_of_range) | 200 | if (!stop || !level_matches || !delay_is_sane || !delay_outside_of_range) |
199 | return NULL; | 201 | return NULL; |
200 | *len = *len - i; | 202 | *len = *len - i; |
@@ -221,7 +223,7 @@ static int bytes; | |||
221 | 223 | ||
222 | 224 | ||
223 | static void | 225 | static void |
224 | read_call (void *cls) | 226 | read_call(void *cls) |
225 | { | 227 | { |
226 | const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls; | 228 | const struct GNUNET_DISK_FileHandle *stdout_read_handle = cls; |
227 | char level[8]; | 229 | char level[8]; |
@@ -230,24 +232,24 @@ read_call (void *cls) | |||
230 | int rd; | 232 | int rd; |
231 | 233 | ||
232 | read_task = NULL; | 234 | read_task = NULL; |
233 | rd = GNUNET_DISK_file_read (stdout_read_handle, buf_ptr, | 235 | rd = GNUNET_DISK_file_read(stdout_read_handle, buf_ptr, |
234 | sizeof (buf) - bytes); | 236 | sizeof(buf) - bytes); |
235 | if (rd > 0) | 237 | if (rd > 0) |
236 | { | 238 | { |
237 | buf_ptr += rd; | 239 | buf_ptr += rd; |
238 | bytes += rd; | 240 | bytes += rd; |
239 | #if VERBOSE | 241 | #if VERBOSE |
240 | fprintf (stderr, "got %d bytes, reading more\n", rd); | 242 | fprintf(stderr, "got %d bytes, reading more\n", rd); |
241 | #endif | 243 | #endif |
242 | read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, | 244 | read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, |
243 | stdout_read_handle, | 245 | stdout_read_handle, |
244 | &read_call, | 246 | &read_call, |
245 | (void*) stdout_read_handle); | 247 | (void*)stdout_read_handle); |
246 | return; | 248 | return; |
247 | } | 249 | } |
248 | 250 | ||
249 | #if VERBOSE | 251 | #if VERBOSE |
250 | fprintf (stderr, "bytes is %d:%s\n", bytes, buf); | 252 | fprintf(stderr, "bytes is %d:%s\n", bytes, buf); |
251 | #endif | 253 | #endif |
252 | 254 | ||
253 | /* +------CHILD OUTPUT-- | 255 | /* +------CHILD OUTPUT-- |
@@ -269,186 +271,195 @@ read_call (void *cls) | |||
269 | 271 | ||
270 | if (bytes == LOG_BUFFER_SIZE || | 272 | if (bytes == LOG_BUFFER_SIZE || |
271 | !(p = | 273 | !(p = |
272 | read_output_line (0, 3, 4, 9, 'L', "ERROR", -1, | 274 | read_output_line(0, 3, 4, 9, 'L', "ERROR", -1, |
273 | 1, phase, p, | 275 | 1, phase, p, |
274 | &bytes, &delay, level)) || | 276 | &bytes, &delay, level)) || |
275 | !(p = | 277 | !(p = |
276 | read_output_line (0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY, | 278 | read_output_line(0, 3, 4, 9, '1', "ERROR", OUTPUT_DELAY, |
277 | MAX_SKIP_DELAY, phase, p, | 279 | MAX_SKIP_DELAY, phase, p, |
278 | &bytes, &delays[0], level)) || | 280 | &bytes, &delays[0], level)) || |
279 | !(p = | 281 | !(p = |
280 | read_output_line (1, 3, 5, 9, 'L', "WARNING", -1, | 282 | read_output_line(1, 3, 5, 9, 'L', "WARNING", -1, |
281 | 1, phase, p, | 283 | 1, phase, p, |
282 | &bytes, &delay, level)) || | 284 | &bytes, &delay, level)) || |
283 | !(p = | 285 | !(p = |
284 | read_output_line (0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY, | 286 | read_output_line(0, 3, 4, 9, '1', "WARNING", OUTPUT_DELAY, |
285 | MAX_SKIP_DELAY, phase, p, | 287 | MAX_SKIP_DELAY, phase, p, |
286 | &bytes, &delays[1], level)) || | 288 | &bytes, &delays[1], level)) || |
287 | !(p = | 289 | !(p = |
288 | read_output_line (2, 3, 6, 7, 'L', "INFO", -1, | 290 | read_output_line(2, 3, 6, 7, 'L', "INFO", -1, |
289 | 1, phase, p, | 291 | 1, phase, p, |
290 | &bytes, &delay, level)) || | 292 | &bytes, &delay, level)) || |
291 | !(p = | 293 | !(p = |
292 | read_output_line (0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY, | 294 | read_output_line(0, 3, 4, 9, '1', "INFO", OUTPUT_DELAY, |
293 | MAX_SKIP_DELAY, phase, p, | 295 | MAX_SKIP_DELAY, phase, p, |
294 | &bytes, &delays[2], level)) || | 296 | &bytes, &delays[2], level)) || |
295 | !(p = | 297 | !(p = |
296 | read_output_line (3, 3, 7, 7, 'L', "DEBUG", -1, | 298 | read_output_line(3, 3, 7, 7, 'L', "DEBUG", -1, |
297 | 1, phase, p, | 299 | 1, phase, p, |
298 | &bytes, &delay, level)) || | 300 | &bytes, &delay, level)) || |
299 | !(p = | 301 | !(p = |
300 | read_output_line (0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY, | 302 | read_output_line(0, 3, 4, 9, '1', "DEBUG", OUTPUT_DELAY, |
301 | MAX_SKIP_DELAY, phase, p, | 303 | MAX_SKIP_DELAY, phase, p, |
302 | &bytes, &delays[3], level)) || | 304 | &bytes, &delays[3], level)) || |
303 | !(p = | 305 | !(p = |
304 | read_output_line (0, 3, 4, 9, 'L', "ERROR", -1, | 306 | read_output_line(0, 3, 4, 9, 'L', "ERROR", -1, |
305 | 1, phase, p, | 307 | 1, phase, p, |
306 | &bytes, &delay, level)) || | 308 | &bytes, &delay, level)) || |
307 | !(p = | 309 | !(p = |
308 | read_output_line (0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY, | 310 | read_output_line(0, 3, 4, 9, '2', "ERROR", OUTPUT_DELAY, |
309 | MAX_SKIP_DELAY, phase, p, | 311 | MAX_SKIP_DELAY, phase, p, |
310 | &bytes, &delays[4], level)) || | 312 | &bytes, &delays[4], level)) || |
311 | !(p = | 313 | !(p = |
312 | read_output_line (0, 3, 5, 9, 'L', "WARNING", -1, | 314 | read_output_line(0, 3, 5, 9, 'L', "WARNING", -1, |
313 | 1, phase, p, | 315 | 1, phase, p, |
314 | &bytes, &delay, level)) || | 316 | &bytes, &delay, level)) || |
315 | !(p = | 317 | !(p = |
316 | read_output_line (0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY, | 318 | read_output_line(0, 3, 4, 9, '2', "WARNING", OUTPUT_DELAY, |
317 | MAX_SKIP_DELAY, phase, p, | 319 | MAX_SKIP_DELAY, phase, p, |
318 | &bytes, &delays[5], level)) || | 320 | &bytes, &delays[5], level)) || |
319 | !(p = | 321 | !(p = |
320 | read_output_line (-1, -1, 6, 7, 'L', "INFO", -1, | 322 | read_output_line(-1, -1, 6, 7, 'L', "INFO", -1, |
321 | 1, phase, p, | 323 | 1, phase, p, |
322 | &bytes, &delay, level)) || | 324 | &bytes, &delay, level)) || |
323 | !(p = | 325 | !(p = |
324 | read_output_line (0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY, | 326 | read_output_line(0, 3, 4, 9, '2', "INFO", OUTPUT_DELAY, |
325 | MAX_SKIP_DELAY, phase, p, | 327 | MAX_SKIP_DELAY, phase, p, |
326 | &bytes, &delays[6], level)) || | 328 | &bytes, &delays[6], level)) || |
327 | !(p = | 329 | !(p = |
328 | read_output_line (-1, -1, 7, 7, 'L', "DEBUG", -1, | 330 | read_output_line(-1, -1, 7, 7, 'L', "DEBUG", -1, |
329 | 1, phase, p, | 331 | 1, phase, p, |
330 | &bytes, &delay, level)) || | 332 | &bytes, &delay, level)) || |
331 | !(p = | 333 | !(p = |
332 | read_output_line (0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY, | 334 | read_output_line(0, 3, 4, 9, '2', "DEBUG", OUTPUT_DELAY, |
333 | MAX_SKIP_DELAY, phase, p, | 335 | MAX_SKIP_DELAY, phase, p, |
334 | &bytes, &delays[7], level))) | 336 | &bytes, &delays[7], level))) |
335 | { | 337 | { |
336 | if (bytes == LOG_BUFFER_SIZE) | 338 | if (bytes == LOG_BUFFER_SIZE) |
337 | fprintf (stderr, "%s", "Ran out of buffer space!\n"); | 339 | fprintf(stderr, "%s", "Ran out of buffer space!\n"); |
338 | GNUNET_break (0); | 340 | GNUNET_break(0); |
339 | ok = 2; | 341 | ok = 2; |
340 | GNUNET_SCHEDULER_cancel (die_task); | 342 | GNUNET_SCHEDULER_cancel(die_task); |
341 | GNUNET_SCHEDULER_add_now (&end_task, NULL); | 343 | GNUNET_SCHEDULER_add_now(&end_task, NULL); |
342 | return; | 344 | return; |
343 | } | 345 | } |
344 | 346 | ||
345 | GNUNET_SCHEDULER_cancel (die_task); | 347 | GNUNET_SCHEDULER_cancel(die_task); |
346 | GNUNET_SCHEDULER_add_now (&end_task, NULL); | 348 | GNUNET_SCHEDULER_add_now(&end_task, NULL); |
347 | } | 349 | } |
348 | 350 | ||
349 | 351 | ||
350 | static void | 352 | static void |
351 | runone () | 353 | runone() |
352 | { | 354 | { |
353 | const struct GNUNET_DISK_FileHandle *stdout_read_handle; | 355 | const struct GNUNET_DISK_FileHandle *stdout_read_handle; |
354 | 356 | ||
355 | pipe_stdout = GNUNET_DISK_pipe (GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); | 357 | pipe_stdout = GNUNET_DISK_pipe(GNUNET_YES, GNUNET_YES, GNUNET_NO, GNUNET_YES); |
356 | 358 | ||
357 | if (pipe_stdout == NULL) | 359 | if (pipe_stdout == NULL) |
358 | { | 360 | { |
359 | GNUNET_break (0); | 361 | GNUNET_break(0); |
360 | ok = 2; | 362 | ok = 2; |
361 | return; | 363 | return; |
362 | } | 364 | } |
363 | 365 | ||
364 | putenv ("GNUNET_LOG="); | 366 | putenv("GNUNET_LOG="); |
365 | putenv ("GNUNET_FORCE_LOG="); | 367 | putenv("GNUNET_FORCE_LOG="); |
366 | putenv ("GNUNET_FORCE_LOGFILE="); | 368 | putenv("GNUNET_FORCE_LOGFILE="); |
367 | switch (phase) | 369 | switch (phase) |
368 | { | 370 | { |
369 | case 0: | 371 | case 0: |
370 | putenv ("GNUNET_LOG=;;;;ERROR"); | 372 | putenv("GNUNET_LOG=;;;;ERROR"); |
371 | break; | 373 | break; |
372 | case 1: | 374 | |
373 | putenv ("GNUNET_LOG=;;;;WARNING"); | 375 | case 1: |
374 | break; | 376 | putenv("GNUNET_LOG=;;;;WARNING"); |
375 | case 2: | 377 | break; |
376 | putenv ("GNUNET_LOG=;;;;INFO"); | 378 | |
377 | break; | 379 | case 2: |
378 | case 3: | 380 | putenv("GNUNET_LOG=;;;;INFO"); |
379 | putenv ("GNUNET_LOG=;;;;DEBUG"); | 381 | break; |
380 | break; | 382 | |
381 | case 4: | 383 | case 3: |
382 | putenv ("GNUNET_FORCE_LOG=;;;;ERROR"); | 384 | putenv("GNUNET_LOG=;;;;DEBUG"); |
383 | break; | 385 | break; |
384 | case 5: | 386 | |
385 | putenv ("GNUNET_FORCE_LOG=;;;;WARNING"); | 387 | case 4: |
386 | break; | 388 | putenv("GNUNET_FORCE_LOG=;;;;ERROR"); |
387 | case 6: | 389 | break; |
388 | putenv ("GNUNET_FORCE_LOG=;;;;INFO"); | 390 | |
389 | break; | 391 | case 5: |
390 | case 7: | 392 | putenv("GNUNET_FORCE_LOG=;;;;WARNING"); |
391 | putenv ("GNUNET_FORCE_LOG=;;;;DEBUG"); | 393 | break; |
392 | break; | 394 | |
393 | case 8: | 395 | case 6: |
394 | putenv ("GNUNET_LOG=blah;;;;ERROR"); | 396 | putenv("GNUNET_FORCE_LOG=;;;;INFO"); |
395 | break; | 397 | break; |
396 | case 9: | 398 | |
397 | putenv ("GNUNET_FORCE_LOG=blah;;;;ERROR"); | 399 | case 7: |
398 | break; | 400 | putenv("GNUNET_FORCE_LOG=;;;;DEBUG"); |
399 | } | 401 | break; |
400 | 402 | ||
401 | proc = GNUNET_OS_start_process (GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | 403 | case 8: |
402 | NULL, pipe_stdout, NULL, | 404 | putenv("GNUNET_LOG=blah;;;;ERROR"); |
405 | break; | ||
406 | |||
407 | case 9: | ||
408 | putenv("GNUNET_FORCE_LOG=blah;;;;ERROR"); | ||
409 | break; | ||
410 | } | ||
411 | |||
412 | proc = GNUNET_OS_start_process(GNUNET_NO, GNUNET_OS_INHERIT_STD_OUT_AND_ERR, | ||
413 | NULL, pipe_stdout, NULL, | ||
403 | #if MINGW | 414 | #if MINGW |
404 | "test_common_logging_dummy", | 415 | "test_common_logging_dummy", |
405 | #else | 416 | #else |
406 | "./test_common_logging_dummy", | 417 | "./test_common_logging_dummy", |
407 | #endif | 418 | #endif |
408 | "test_common_logging_dummy", NULL); | 419 | "test_common_logging_dummy", NULL); |
409 | GNUNET_assert (NULL != proc); | 420 | GNUNET_assert(NULL != proc); |
410 | putenv ("GNUNET_FORCE_LOG="); | 421 | putenv("GNUNET_FORCE_LOG="); |
411 | putenv ("GNUNET_LOG="); | 422 | putenv("GNUNET_LOG="); |
412 | 423 | ||
413 | /* Close the write end of the read pipe */ | 424 | /* Close the write end of the read pipe */ |
414 | GNUNET_DISK_pipe_close_end (pipe_stdout, GNUNET_DISK_PIPE_END_WRITE); | 425 | GNUNET_DISK_pipe_close_end(pipe_stdout, GNUNET_DISK_PIPE_END_WRITE); |
415 | 426 | ||
416 | stdout_read_handle = | 427 | stdout_read_handle = |
417 | GNUNET_DISK_pipe_handle (pipe_stdout, GNUNET_DISK_PIPE_END_READ); | 428 | GNUNET_DISK_pipe_handle(pipe_stdout, GNUNET_DISK_PIPE_END_READ); |
418 | 429 | ||
419 | die_task = | 430 | die_task = |
420 | GNUNET_SCHEDULER_add_delayed (GNUNET_TIME_relative_multiply | 431 | GNUNET_SCHEDULER_add_delayed(GNUNET_TIME_relative_multiply |
421 | (GNUNET_TIME_UNIT_SECONDS, 10), | 432 | (GNUNET_TIME_UNIT_SECONDS, 10), |
422 | &end_task, | 433 | &end_task, |
423 | NULL); | 434 | NULL); |
424 | 435 | ||
425 | bytes = 0; | 436 | bytes = 0; |
426 | buf_ptr = buf; | 437 | buf_ptr = buf; |
427 | memset (&buf, 0, sizeof (buf)); | 438 | memset(&buf, 0, sizeof(buf)); |
428 | 439 | ||
429 | read_task = GNUNET_SCHEDULER_add_read_file (GNUNET_TIME_UNIT_FOREVER_REL, | 440 | read_task = GNUNET_SCHEDULER_add_read_file(GNUNET_TIME_UNIT_FOREVER_REL, |
430 | stdout_read_handle, | 441 | stdout_read_handle, |
431 | &read_call, | 442 | &read_call, |
432 | (void*) stdout_read_handle); | 443 | (void*)stdout_read_handle); |
433 | } | 444 | } |
434 | 445 | ||
435 | 446 | ||
436 | static void | 447 | static void |
437 | task (void *cls) | 448 | task(void *cls) |
438 | { | 449 | { |
439 | phase = 0; | 450 | phase = 0; |
440 | runone (); | 451 | runone(); |
441 | } | 452 | } |
442 | 453 | ||
443 | 454 | ||
444 | int | 455 | int |
445 | main (int argc, char *argv[]) | 456 | main(int argc, char *argv[]) |
446 | { | 457 | { |
447 | GNUNET_log_setup ("test-common-logging-runtime-loglevels", | 458 | GNUNET_log_setup("test-common-logging-runtime-loglevels", |
448 | "WARNING", | 459 | "WARNING", |
449 | NULL); | 460 | NULL); |
450 | ok = 1; | 461 | ok = 1; |
451 | GNUNET_SCHEDULER_run (&task, &ok); | 462 | GNUNET_SCHEDULER_run(&task, &ok); |
452 | return ok; | 463 | return ok; |
453 | } | 464 | } |
454 | 465 | ||