1 #include <cgreen/mocks.h>
2 #include <string.h>
3
4 static const int do_expand = TRUE;
5 static const int do_not_expand = FALSE;
6
expect_config_lookup(const char * ret_from_config,int do_expand)7 static void expect_config_lookup(const char *ret_from_config,
8 int do_expand)
9 {
10 int len = strlen(ret_from_config) + 1;
11
12 expect(cf_p_logfile,
13 will_return(ret_from_config));
14 if (!do_expand)
15 return;
16
17 expect(str_expand_name,
18 when(s, is_equal_to(ret_from_config)),
19 will_set_contents_of_parameter(d,
20 ret_from_config,
21 len),
22 will_return(ret_from_config));
23 }
24
25 /*
26 * Since the functions are mocked, it's needed to check mocks.
27 * Otherwise, complains, that mocked function call wasn't expected.
28 * So, we cannot call just log_file()
29 */
30
expect_file_config_lookup(void)31 static void expect_file_config_lookup(void)
32 {
33 expect_config_lookup(config_file, do_expand);
34 }
35
expect_stdout_config_lookup(void)36 static void expect_stdout_config_lookup(void)
37 {
38 expect_config_lookup(config_stdout, do_not_expand);
39 }
40
expect_output_beginning(FILE * fp,const char * msg,const char * name)41 static void *expect_output_beginning(FILE *fp,
42 const char *msg, const char *name)
43 {
44 char *exp1;
45
46 exp1 = create_string("%s %s ", date_const, name);
47
48 expect(mock_fprintf,
49 when(res_str, is_equal_to_string(exp1)),
50 when(stream, is_equal_to(fp)));
51 expect(mock_vfprintf,
52 when(res_str,
53 is_equal_to_string(msg)),
54 when(stream, is_equal_to(fp)));
55 return exp1;
56 }
57
expect_full_output(FILE * fp,const char * msg,const char * name)58 static void *expect_full_output(FILE *fp,
59 const char *msg, const char *name)
60 {
61 void *to_free;
62
63 to_free = expect_output_beginning(fp, msg, name);
64
65 expect(mock_fprintf,
66 when(res_str, is_equal_to_string("\n")),
67 when(stream, is_equal_to(fp)));
68 return to_free;
69 }
70
expect_full_output_file(FILE * fp,const char * msg,const char * name,const char * log_filename)71 static void *expect_full_output_file(FILE *fp,
72 const char *msg,
73 const char *name,
74 const char *log_filename)
75 {
76 void *to_free;
77
78 expect(mock_fopen,
79 when(path, is_equal_to_string(log_filename)),
80 when(mode, is_equal_to_string(A_MODE)),
81 will_return(fp));
82
83 to_free = expect_full_output(fp, msg, name);
84 expect(mock_fclose,
85 when(file, is_equal_to(fp)));
86 return to_free;
87 }
88
expect_full_errno_output(FILE * fp,const char * msg,const char * name,void ** to_free1,void ** to_free2)89 static void expect_full_errno_output(FILE *fp,
90 const char *msg, const char *name,
91 void **to_free1, void **to_free2)
92 {
93 void *to_free;
94 char *exp;
95
96 to_free = expect_output_beginning(fp, msg + 1, name);
97
98 exp = create_string(" (errno=%d: %m)", errno);
99
100 expect(mock_fprintf,
101 when(res_str, is_equal_to_string(exp)),
102 when(stream, is_equal_to(fp)));
103
104 expect(mock_fprintf,
105 when(res_str, is_equal_to_string("\n")),
106 when(stream, is_equal_to(fp)));
107 *to_free1 = to_free;
108 *to_free2 = exp;
109 }
110
Ensure(fglog_sets_file_from_config)111 Ensure(fglog_sets_file_from_config) {
112 const char *res;
113
114 expect_file_config_lookup();
115
116 expect(mock_fprintf);
117 expect(mock_fopen);
118
119 fglog(normal_log_msg);
120
121 res = log_get_filename();
122
123 assert_that(res, is_equal_to_string(config_file));
124 }
125
Ensure(fglog_does_not_change_file)126 Ensure(fglog_does_not_change_file) {
127 const char *res;
128
129 expect_file_config_lookup();
130
131 /* will set to config_file */
132 log_file(cf_p_logfile());
133
134 never_expect(cf_p_logfile); /* not anymore */
135
136 expect(mock_fprintf);
137 expect(mock_fopen);
138
139 fglog(normal_log_msg);
140
141 res = log_get_filename();
142
143 assert_that(res, is_equal_to_string(config_file));
144 }
145
Ensure(fglog_does_simple_output_stdout)146 Ensure(fglog_does_simple_output_stdout) {
147 FILE *fp = stdout;
148 void *to_free;
149
150 expect_stdout_config_lookup();
151
152 to_free = expect_full_output(fp, normal_log_msg, default_name);
153
154 fglog(normal_log_msg);
155 free(to_free);
156 }
157
Ensure(fglog_does_errno_output_stdout)158 Ensure(fglog_does_errno_output_stdout) {
159 FILE *fp = stdout;
160 void *to_free1;
161 void *to_free2;
162
163 expect_stdout_config_lookup();
164
165 expect_full_errno_output(fp, errno_log_msg, default_name,
166 &to_free1, &to_free2);
167
168 fglog(errno_log_msg);
169
170 free(to_free2);
171 free(to_free1);
172 }
173
Ensure(fglog_does_simple_output_file)174 Ensure(fglog_does_simple_output_file) {
175 FILE *fp = dummy_fp;
176 char *to_free;
177
178 expect_file_config_lookup();
179
180 to_free = expect_full_output_file(fp,
181 normal_log_msg, default_name,
182 config_file);
183
184 fglog(normal_log_msg);
185 free(to_free);
186 }
187
Ensure(fglog_prints_for_wrong_file)188 Ensure(fglog_prints_for_wrong_file) {
189 char *exp1;
190 const char *exp_log_filename = config_file;
191 int new_errno = ECONNRESET;
192 const char *exp_log_prog = default_name;
193
194 expect_file_config_lookup();
195
196 expect(mock_fopen,
197 when(path, is_equal_to_string(exp_log_filename)),
198 when(mode, is_equal_to_string(A_MODE)),
199 will_set_contents_of_parameter(local_errno,
200 &new_errno,
201 sizeof(int)),
202 will_return(NULL));
203
204 exp1 = create_string("%s WARNING: can't open log file %s "
205 "(errno=%d: %s)\n",
206 exp_log_prog, exp_log_filename,
207 new_errno, strerror(new_errno));
208
209 expect(mock_fprintf,
210 when(res_str, is_equal_to_string(exp1)),
211 when(stream, is_equal_to(stderr)));
212 never_expect(mock_vfprintf);
213 never_expect(mock_fprintf);
214 never_expect(mock_fclose);
215
216 fglog(normal_log_msg);
217
218 free(exp1);
219 }
220
Ensure(fglog_resets_default_verbose_for_wrong_file)221 Ensure(fglog_resets_default_verbose_for_wrong_file)
222 {
223 expect_file_config_lookup();
224
225 expect(mock_fopen,
226 will_return(NULL));
227 expect(mock_fprintf);
228 log_set_verbose(0);
229
230 fglog(normal_log_msg);
231 assert_that(log_get_verbose(), is_equal_to(-1));
232 }
233
Ensure(fglog_ignores_high_verbose_for_wrong_file)234 Ensure(fglog_ignores_high_verbose_for_wrong_file)
235 {
236 expect_file_config_lookup();
237
238 expect(mock_fopen,
239 will_return(NULL));
240 expect(mock_fprintf);
241 log_set_verbose(10);
242
243 fglog(normal_log_msg);
244 assert_that(log_get_verbose(), is_equal_to(10));
245 }
246
Ensure(fglog_opens_file_every_time)247 Ensure(fglog_opens_file_every_time)
248 {
249 FILE *fp = dummy_fp;
250 const char *exp_log_filename = config_file;
251
252 expect_file_config_lookup();
253
254 expect(mock_fopen,
255 when(path, is_equal_to_string(exp_log_filename)),
256 when(mode, is_equal_to_string(A_MODE)),
257 will_return(fp));
258
259 expect(mock_fprintf);
260 expect(mock_vfprintf);
261 expect(mock_fprintf);
262 expect(mock_fclose);
263
264 /* Second time */
265 expect(mock_fopen,
266 when(path, is_equal_to_string(exp_log_filename)),
267 when(mode, is_equal_to_string(A_MODE)),
268 will_return(fp));
269
270 expect(mock_fprintf);
271 expect(mock_vfprintf);
272 expect(mock_fprintf);
273 expect(mock_fclose);
274
275 fglog(normal_log_msg);
276 fglog(normal_log_msg);
277 }
278
Ensure(fglog_outputs_after_log_program)279 Ensure(fglog_outputs_after_log_program)
280 {
281 FILE *fp = stdout;
282 void *to_free;
283
284 expect_stdout_config_lookup();
285 to_free = expect_full_output(fp, normal_log_msg, custom_name);
286
287 log_program(custom_name);
288 fglog(normal_log_msg);
289
290 free(to_free);
291 }
292
Ensure(fglog_outputs_after_log_file_stdout)293 Ensure(fglog_outputs_after_log_file_stdout)
294 {
295 FILE *fp = stdout;
296 void *to_free;
297
298 never_expect(cf_p_logfile);
299 to_free = expect_full_output(fp, normal_log_msg, default_name);
300
301 log_file("stdout");
302 fglog(normal_log_msg);
303
304 free(to_free);
305 }
306
Ensure(fglog_outputs_after_log_file_file)307 Ensure(fglog_outputs_after_log_file_file)
308 {
309 FILE *fp = dummy_fp;
310 void *to_free;
311
312 never_expect(cf_p_logfile);
313 expect(str_expand_name,
314 when(s, is_equal_to(config_file)),
315 will_set_contents_of_parameter(d,
316 config_file,
317 sizeof(config_file)),
318 will_return(config_file));
319 to_free = expect_full_output_file(fp,
320 normal_log_msg, default_name,
321 config_file);
322 log_file(config_file);
323 fglog(normal_log_msg);
324
325 free(to_free);
326 }
327
Ensure(fglog_outputs_after_log_program_log_file_stdout)328 Ensure(fglog_outputs_after_log_program_log_file_stdout)
329 {
330 FILE *fp = stdout;
331 void *to_free;
332
333 never_expect(cf_p_logfile);
334 to_free = expect_full_output(fp, normal_log_msg, custom_name);
335
336 log_program(custom_name);
337 log_file("stdout");
338 fglog(normal_log_msg);
339
340 free(to_free);
341 }
342
Ensure(fglog_outputs_after_log_program_log_file_file)343 Ensure(fglog_outputs_after_log_program_log_file_file)
344 {
345 FILE *fp = dummy_fp;
346 void *to_free;
347
348 never_expect(cf_p_logfile);
349 expect(str_expand_name,
350 when(s, is_equal_to(config_file)),
351 will_set_contents_of_parameter(d,
352 config_file,
353 sizeof(config_file)),
354 will_return(config_file));
355 to_free = expect_full_output_file(fp,
356 normal_log_msg, custom_name,
357 config_file);
358
359 log_program(custom_name);
360 log_file(config_file);
361 fglog(normal_log_msg);
362
363 free(to_free);
364 }
365
Ensure(fglog_outputs_after_log_file_stdout_log_program)366 Ensure(fglog_outputs_after_log_file_stdout_log_program)
367 {
368 FILE *fp = stdout;
369 void *to_free;
370
371 never_expect(cf_p_logfile);
372 to_free = expect_full_output(fp, normal_log_msg, custom_name);
373
374 log_file("stdout");
375 log_program(custom_name);
376 fglog(normal_log_msg);
377
378 free(to_free);
379 }
380
Ensure(fglog_outputs_after_log_file_file_log_program)381 Ensure(fglog_outputs_after_log_file_file_log_program)
382 {
383 FILE *fp = dummy_fp;
384 void *to_free;
385
386 never_expect(cf_p_logfile);
387 expect(str_expand_name,
388 when(s, is_equal_to(config_file)),
389 will_set_contents_of_parameter(d,
390 config_file,
391 sizeof(config_file)),
392 will_return(config_file));
393 to_free = expect_full_output_file(fp,
394 normal_log_msg, custom_name,
395 config_file);
396 log_file(config_file);
397 log_program(custom_name);
398 fglog(normal_log_msg);
399
400 free(to_free);
401 }
402
Ensure(fglog_works_after_debug)403 Ensure(fglog_works_after_debug)
404 {
405 FILE *fp = dummy_fp;
406 char *to_free;
407 int debug_level = -1; /* less then default 0 */
408
409 /* debug() calls */
410 expect(mock_vfprintf,
411 when(stream, is_equal_to(stderr)));
412 expect(mock_fprintf,
413 when(stream, is_equal_to(stderr)));
414 expect(mock_fflush,
415 when(file, is_equal_to(stderr)));
416 /* fglog() calls */
417 expect_file_config_lookup();
418 to_free = expect_full_output_file(fp,
419 normal_log_msg, default_name,
420 config_file);
421
422 debug(debug_level, "some debug");
423 fglog(normal_log_msg); /* it did hang because of bug */
424
425 free(to_free);
426 }
427
428 #include "test-log-fglog-syslog.c"
429
create_log_fglog_suite(void)430 TestSuite *create_log_fglog_suite(void)
431 {
432 TestSuite *suite = create_named_test_suite("fglog() suite");
433
434 add_test(suite, fglog_sets_file_from_config);
435 add_test(suite, fglog_does_not_change_file);
436 add_test(suite, fglog_does_simple_output_stdout);
437 add_test(suite, fglog_does_errno_output_stdout);
438 add_test(suite, fglog_does_simple_output_file);
439 add_test(suite, fglog_prints_for_wrong_file);
440 add_test(suite, fglog_resets_default_verbose_for_wrong_file);
441 add_test(suite, fglog_ignores_high_verbose_for_wrong_file);
442 add_test(suite, fglog_opens_file_every_time);
443 add_test(suite, fglog_outputs_after_log_program);
444 add_test(suite, fglog_outputs_after_log_file_stdout);
445 add_test(suite, fglog_outputs_after_log_file_file);
446 add_test(suite, fglog_outputs_after_log_program_log_file_stdout);
447 add_test(suite, fglog_outputs_after_log_program_log_file_file);
448 add_test(suite, fglog_outputs_after_log_file_stdout_log_program);
449 add_test(suite, fglog_outputs_after_log_file_file_log_program);
450 add_test(suite, fglog_works_after_debug);
451
452 add_fglog_syslog(suite);
453
454 set_setup(suite, log_init_globals);
455
456 return suite;
457 }
458