Debian Codegraph @

test/test_cases.include

raw
1
2
3 TEST_F(FFFTestSuite, when_void_func_never_called_then_callcount_is_zero)
4 {
5 ASSERT_EQ(voidfunc1_fake.call_count, 0u);
6 }
7
8 TEST_F(FFFTestSuite, when_void_func_called_once_then_callcount_is_one)
9 {
10 voidfunc1(66);
11 ASSERT_EQ(voidfunc1_fake.call_count, 1u);
12 }
13
14 TEST_F(FFFTestSuite, when_void_func_called_once_and_reset_then_callcount_is_zero)
15 {
16 voidfunc1(66);
17 RESET_FAKE(voidfunc1);
18 ASSERT_EQ(voidfunc1_fake.call_count, 0u);
19 }
20
21 // Single Argument
22 TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_then_last_arg_captured)
23 {
24 voidfunc1(77);
25 ASSERT_EQ(voidfunc1_fake.arg0_val, 77);
26 }
27
28 TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_twice_then_last_arg_captured)
29 {
30 voidfunc1(77);
31 voidfunc1(12);
32 ASSERT_EQ(voidfunc1_fake.arg0_val, 12);
33 }
34
35 TEST_F(FFFTestSuite, when_void_func_with_1_integer_arg_called_and_reset_then_captured_arg_is_zero)
36 {
37 voidfunc1(11);
38 RESET_FAKE(voidfunc1);
39 ASSERT_EQ(voidfunc1_fake.arg0_val, 0);
40 }
41
42 // Two Arguments
43 TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_then_last_args_captured)
44 {
45 voidfunc2('a', 'b');
46 ASSERT_EQ(voidfunc2_fake.arg0_val, 'a');
47 ASSERT_EQ(voidfunc2_fake.arg1_val, 'b');
48 }
49
50 TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_twice_then_last_args_captured)
51 {
52 voidfunc2('a', 'b');
53 voidfunc2('c', 'd');
54 ASSERT_EQ(voidfunc2_fake.arg0_val, 'c');
55 ASSERT_EQ(voidfunc2_fake.arg1_val, 'd');
56 }
57
58 TEST_F(FFFTestSuite, when_void_func_with_2_char_args_called_and_reset_then_captured_arg_is_zero)
59 {
60 voidfunc2('e', 'f');
61 RESET_FAKE(voidfunc2);
62 ASSERT_EQ(voidfunc2_fake.arg0_val, 0);
63 ASSERT_EQ(voidfunc2_fake.arg1_val, 0);
64 }
65
66 #ifndef __cplusplus
67 TEST_F(FFFTestSuite, when_fake_func_called_then_const_arguments_captured)
68 {
69 char dst[80];
70 strlcpy3(dst, __FUNCTION__, sizeof(__FUNCTION__));
71 }
72 #endif /* __cplusplus */
73
74 // Argument history
75 TEST_F(FFFTestSuite, when_fake_func_created_default_history_is_fifty_calls)
76 {
77 ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg0_history) / (sizeof voidfunc2_fake.arg0_history[0]));
78 ASSERT_EQ(FFF_ARG_HISTORY_LEN, (sizeof voidfunc2_fake.arg1_history) / (sizeof voidfunc2_fake.arg1_history[0]));
79 }
80
81 TEST_F(FFFTestSuite, when_fake_func_called_then_arguments_captured_in_history)
82 {
83 voidfunc2('g', 'h');
84 ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]);
85 ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]);
86 }
87
88 TEST_F(FFFTestSuite, argument_history_is_reset_when_RESET_FAKE_called)
89 {
90 //given
91 voidfunc2('g', 'h');
92 ASSERT_EQ('g', voidfunc2_fake.arg0_history[0]);
93 ASSERT_EQ('h', voidfunc2_fake.arg1_history[0]);
94 //when
95 RESET_FAKE(voidfunc2);
96 //then
97 ASSERT_EQ('\0', voidfunc2_fake.arg0_history[0]);
98 ASSERT_EQ('\0', voidfunc2_fake.arg1_history[0]);
99 }
100
101 TEST_F(FFFTestSuite, when_fake_func_called_max_times_then_no_argument_histories_dropped)
102 {
103 unsigned int i;
104 for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
105 {
106 voidfunc2('1' + i, '2' + i);
107 }
108 ASSERT_EQ(0u, voidfunc2_fake.arg_histories_dropped);
109 }
110
111 TEST_F(FFFTestSuite, when_fake_func_called_max_times_plus_one_then_one_argument_history_dropped)
112 {
113 unsigned int i;
114 for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
115 {
116 voidfunc2('1' + i, '2' + i);
117 }
118 voidfunc2('1', '2');
119 ASSERT_EQ(1u, voidfunc2_fake.arg_histories_dropped);
120 // or in other words..
121 ASSERT_TRUE(voidfunc2_fake.call_count > voidfunc2_fake.arg_history_len);
122 }
123
124 // Return values
125 TEST_F(FFFTestSuite, value_func_will_return_zero_by_default)
126 {
127 ASSERT_EQ(0l, longfunc0());
128 }
129
130 TEST_F(FFFTestSuite, value_func_will_return_value_given)
131 {
132 longfunc0_fake.return_val = 99l;
133 ASSERT_EQ(99l, longfunc0());
134 }
135
136 TEST_F(FFFTestSuite, value_func_will_return_zero_after_reset)
137 {
138 longfunc0_fake.return_val = 99l;
139 RESET_FAKE(longfunc0);
140 ASSERT_EQ(0l, longfunc0());
141 }
142
143 TEST_F(FFFTestSuite, register_call_macro_registers_one_call)
144 {
145 REGISTER_CALL(longfunc0);
146 ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
147 }
148
149 TEST_F(FFFTestSuite, register_call_macro_registers_two_calls)
150 {
151 REGISTER_CALL(longfunc0);
152 REGISTER_CALL(voidfunc2);
153
154 ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
155 ASSERT_EQ(fff.call_history[1], (void *)voidfunc2);
156 }
157
158 TEST_F(FFFTestSuite, reset_call_history_resets_call_history)
159 {
160 REGISTER_CALL(longfunc0);
161 REGISTER_CALL(voidfunc1);
162 FFF_RESET_HISTORY();
163 REGISTER_CALL(voidfunc2);
164
165 ASSERT_EQ(1u, fff.call_history_idx);
166 ASSERT_EQ(fff.call_history[0], (void *)voidfunc2);
167 ASSERT_EQ(fff.call_history[1], (void *)0);
168 }
169
170 TEST_F(FFFTestSuite, call_history_will_not_write_past_array_bounds)
171 {
172 for (unsigned int i = 0; i < FFF_CALL_HISTORY_LEN + 1; i++)
173 {
174 REGISTER_CALL(longfunc0);
175 }
176 ASSERT_EQ(FFF_CALL_HISTORY_LEN, fff.call_history_idx);
177 }
178
179 TEST_F(FFFTestSuite, calling_fake_registers_one_call)
180 {
181 longfunc0();
182 ASSERT_EQ(fff.call_history_idx, 1u);
183 ASSERT_EQ(fff.call_history[0], (void *)longfunc0);
184 }
185
186 TEST_F(FFFTestSuite, return_value_sequences_not_exhausted)
187 {
188 long myReturnVals[3] = { 3, 7, 9 };
189 SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
190 ASSERT_EQ(myReturnVals[0], longfunc0());
191 ASSERT_EQ(myReturnVals[1], longfunc0());
192 ASSERT_EQ(myReturnVals[2], longfunc0());
193 }
194
195
196 TEST_F(FFFTestSuite, return_value_sequences_exhausted)
197 {
198 long myReturnVals[3] = { 3, 7, 9 };
199 SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
200 ASSERT_EQ(myReturnVals[0], longfunc0());
201 ASSERT_EQ(myReturnVals[1], longfunc0());
202 ASSERT_EQ(myReturnVals[2], longfunc0());
203 ASSERT_EQ(myReturnVals[2], longfunc0());
204 ASSERT_EQ(myReturnVals[2], longfunc0());
205 }
206
207 TEST_F(FFFTestSuite, return_value_sequences_reset)
208 {
209 long myReturnVals[3] = { 3, 7, 9 };
210 SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
211 ASSERT_EQ(myReturnVals[0], longfunc0());
212 ASSERT_EQ(myReturnVals[1], longfunc0());
213 RESET_FAKE(longfunc0);
214 ASSERT_EQ(0, longfunc0());
215 }
216
217 static int my_custom_fake_called = 0;
218 void my_custom_fake(char a, char b)
219 {
220 my_custom_fake_called++;
221 }
222
223 TEST_F(FFFTestSuite, can_register_custom_fake)
224 {
225 voidfunc2_fake.custom_fake = my_custom_fake;
226 voidfunc2('a', 'b');
227 ASSERT_EQ(1, my_custom_fake_called);
228 }
229
230 void voidfunc1outparam_custom_fake1(char *a)
231 {
232 *a = 'x';
233 }
234
235 void voidfunc1outparam_custom_fake2(char *a)
236 {
237 *a = 'y';
238 }
239
240 void voidfunc1outparam_custom_fake3(char *a)
241 {
242 *a = 'z';
243 }
244
245 TEST_F(FFFTestSuite, custom_fake_sequence_not_exausthed)
246 {
247 void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1,
248 voidfunc1outparam_custom_fake2,
249 voidfunc1outparam_custom_fake3};
250 char a = 'a';
251
252 SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3);
253
254 voidfunc1outparam(&a);
255 ASSERT_EQ('x', a);
256 voidfunc1outparam(&a);
257 ASSERT_EQ('y', a);
258 voidfunc1outparam(&a);
259 ASSERT_EQ('z', a);
260 }
261
262 TEST_F(FFFTestSuite, return_value_sequence_saved_in_history)
263 {
264 long myReturnVals[3] = { 3, 7, 9 };
265 SET_RETURN_SEQ(longfunc0, myReturnVals, 3);
266 longfunc0();
267 longfunc0();
268 longfunc0();
269 ASSERT_EQ(myReturnVals[0], longfunc0_fake.return_val_history[0]);
270 ASSERT_EQ(myReturnVals[1], longfunc0_fake.return_val_history[1]);
271 ASSERT_EQ(myReturnVals[2], longfunc0_fake.return_val_history[2]);
272 }
273
274 TEST_F(FFFTestSuite, return_value_saved_in_history)
275 {
276 long i;
277
278 for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
279 {
280 longfunc0_fake.return_val = i + 1;
281 longfunc0();
282 }
283
284 for (i = 0; i < FFF_ARG_HISTORY_LEN; i++)
285 {
286 ASSERT_EQ(longfunc0_fake.return_val_history[i], i + 1);
287 }
288 }
289
290 long custom_longfunc1(void)
291 {
292 return 42;
293 }
294
295 long custom_longfunc2(void)
296 {
297 return 15;
298 }
299
300 long custom_longfunc3(void)
301 {
302 return 7;
303 }
304
305 TEST_F(FFFTestSuite, custom_fake_seq_return_values_saved_in_history)
306 {
307 long (*custom_fakes[])(void) = {custom_longfunc1,
308 custom_longfunc2,
309 custom_longfunc3};
310
311 SET_CUSTOM_FAKE_SEQ(longfunc0, custom_fakes, 3);
312
313 longfunc0();
314 longfunc0();
315 longfunc0();
316
317 ASSERT_EQ(42, longfunc0_fake.return_val_history[0]);
318 ASSERT_EQ(15, longfunc0_fake.return_val_history[1]);
319 ASSERT_EQ(7, longfunc0_fake.return_val_history[2]);
320 }
321
322 TEST_F(FFFTestSuite, custom_fake_sequence_exhausted)
323 {
324 void (*custom_fakes[])(char *) = {voidfunc1outparam_custom_fake1,
325 voidfunc1outparam_custom_fake2,
326 voidfunc1outparam_custom_fake3};
327 char a = 'a';
328
329 SET_CUSTOM_FAKE_SEQ(voidfunc1outparam, custom_fakes, 3);
330
331 voidfunc1outparam(&a);
332 ASSERT_EQ('x', a);
333 voidfunc1outparam(&a);
334 ASSERT_EQ('y', a);
335 voidfunc1outparam(&a);
336 ASSERT_EQ('z', a);
337 a = 'a';
338 voidfunc1outparam(&a);
339 ASSERT_EQ('z', a);
340 a = 'b';
341 voidfunc1outparam(&a);
342 ASSERT_EQ('z', a);
343 }
344 //DECLARE_FAKE_VALUE_FUNC0(long, longfunc0);
345 #define MEANING_OF_LIFE 42
346 long my_custom_value_fake(void)
347 {
348 return MEANING_OF_LIFE;
349 }
350
351 long my_custom_value_fake2(void)
352 {
353 static long val = 0;
354 return val++;
355 }
356
357 TEST_F(FFFTestSuite, when_value_custom_fake_called_THEN_it_returns_custom_return_value)
358 {
359 longfunc0_fake.custom_fake = my_custom_value_fake;
360 long retval = longfunc0();
361 ASSERT_EQ(MEANING_OF_LIFE, retval);
362 }
363
364 TEST_F(FFFTestSuite, return_values_from_custom_fake_saved_in_history)
365 {
366 longfunc0_fake.custom_fake = my_custom_value_fake2;
367 longfunc0();
368 longfunc0();
369 longfunc0();
370
371 ASSERT_EQ(0, longfunc0_fake.return_val_history[0]);
372 ASSERT_EQ(1, longfunc0_fake.return_val_history[1]);
373 ASSERT_EQ(2, longfunc0_fake.return_val_history[2]);
374 }
375
376 int valuefunc3var_custom_fake1(const char *str, int a, va_list vl)
377 {
378 int arg;
379 while ((arg = va_arg(vl, int)) != 0)
380 a += arg;
381 return a;
382 }
383
384 int valuefunc3var_custom_fake2(const char *str, int a, va_list vl)
385 {
386 int arg;
387 while ((arg = va_arg(vl, int)) != 0)
388 a -= arg;
389 return a;
390 }
391
392 int valuefunc3var_custom_fake3(const char *str, int a, va_list vl)
393 {
394 int arg;
395 while ((arg = va_arg(vl, int)) != 0)
396 a *= arg;
397 return a;
398 }
399
400 TEST_F(FFFTestSuite, vararg_custom_fake_sequence_not_exhausted)
401 {
402 int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
403 valuefunc3var_custom_fake2,
404 valuefunc3var_custom_fake3};
405 SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
406 int a = 1;
407 ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
408 ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
409 ASSERT_EQ(valuefunc3var("aaa", a, 2, 3, 0), 6);
410 }
411
412 TEST_F(FFFTestSuite, vararg_custom_fake_seq_return_values_saved_in_history)
413 {
414 int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
415 valuefunc3var_custom_fake2,
416 valuefunc3var_custom_fake3};
417 SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
418 int a = 1;
419 valuefunc3var("a", a, 2, 3, 4, 0);
420 valuefunc3var("aa", a, 2, 3, 4, 2, 0);
421 valuefunc3var("aaa", a, 2, 3, 0);
422 ASSERT_EQ(10, valuefunc3var_fake.return_val_history[0]);
423 ASSERT_EQ(-10, valuefunc3var_fake.return_val_history[1]);
424 ASSERT_EQ(6, valuefunc3var_fake.return_val_history[2]);
425 }
426
427 TEST_F(FFFTestSuite, vararg_custom_fake_sequence_exhausted)
428 {
429 int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
430 valuefunc3var_custom_fake2,
431 valuefunc3var_custom_fake3};
432 SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
433 int a = 1;
434 ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
435 ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
436 ASSERT_EQ(valuefunc3var("aaa", a, 2, 3, 0), 6);
437 ASSERT_EQ(valuefunc3var("aaa", a, 4, 5, 1, 0), 20);
438 ASSERT_EQ(valuefunc3var("aaa", a, 4, 0), 4);
439 }
440
441 TEST_F(FFFTestSuite, vararg_custom_fake_sequence_reset)
442 {
443 int (*custom_fakes[])(const char *, int, va_list) = {valuefunc3var_custom_fake1,
444 valuefunc3var_custom_fake2,
445 valuefunc3var_custom_fake3};
446 SET_CUSTOM_FAKE_SEQ(valuefunc3var, custom_fakes, 3);
447 int a = 1;
448 ASSERT_EQ(valuefunc3var("a", a, 2, 3, 4, 0), 10);
449 ASSERT_EQ(valuefunc3var("aa", a, 2, 3, 4, 2, 0), -10);
450 RESET_FAKE(valuefunc3var);
451 ASSERT_EQ(0, valuefunc3var("b", 7, 4, 5));
452 valuefunc3var_fake.return_val = 1;
453 ASSERT_EQ(1, valuefunc3var("c", 5, 4, 4));
454 valuefunc3var_fake.return_val = 2;
455 ASSERT_EQ(2, valuefunc3var("d", 6, 3, 5));
456 }
457
458 TEST_F(FFFTestSuite, use_void_vararg_fake_with_different_number_of_arguments)
459 {
460 voidfunc3var("0 parameters", 0);
461 voidfunc3var("1 parameter", 1, 10);
462 voidfunc3var("2 parameters", 2, 10, 20);
463 voidfunc3var("3 parameters", 3, 10, 20, 30);
464
465 ASSERT_EQ(voidfunc3var_fake.call_count, 4u);
466 char msg[] = "3 parameters";
467 ASSERT_EQ(strcmp(voidfunc3var_fake.arg0_val, msg), 0);
468 ASSERT_EQ(3, voidfunc3var_fake.arg1_val);
469 }
470
471 TEST_F(FFFTestSuite, use_value_vararg_fake_with_different_number_of_arguments)
472 {
473 valuefunc3var("0 parameters", 0);
474 valuefunc3var("1 parameter", 1, 10);
475 valuefunc3var("2 parameters", 2, 10, 20);
476 valuefunc3var("3 parameters", 3, 10, 20, 30);
477
478 ASSERT_EQ(valuefunc3var_fake.call_count, 4u);
479 char msg[] = "3 parameters";
480 ASSERT_EQ(strcmp(valuefunc3var_fake.arg0_val, msg), 0);
481 ASSERT_EQ(3, valuefunc3var_fake.arg1_val);
482 }
483
484 TEST_F(FFFTestSuite, can_capture_upto_20_arguments_correctly)
485 {
486 voidfunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
487 ASSERT_EQ(0, voidfunc20_fake.arg0_val);
488 ASSERT_EQ(1, voidfunc20_fake.arg1_val);
489 ASSERT_EQ(2, voidfunc20_fake.arg2_val);
490 ASSERT_EQ(3, voidfunc20_fake.arg3_val);
491 ASSERT_EQ(4, voidfunc20_fake.arg4_val);
492 ASSERT_EQ(5, voidfunc20_fake.arg5_val);
493 ASSERT_EQ(6, voidfunc20_fake.arg6_val);
494 ASSERT_EQ(7, voidfunc20_fake.arg7_val);
495 ASSERT_EQ(8, voidfunc20_fake.arg8_val);
496 ASSERT_EQ(9, voidfunc20_fake.arg9_val);
497 ASSERT_EQ(10, voidfunc20_fake.arg10_val);
498 ASSERT_EQ(11, voidfunc20_fake.arg11_val);
499 ASSERT_EQ(12, voidfunc20_fake.arg12_val);
500 ASSERT_EQ(13, voidfunc20_fake.arg13_val);
501 ASSERT_EQ(14, voidfunc20_fake.arg14_val);
502 ASSERT_EQ(15, voidfunc20_fake.arg15_val);
503 ASSERT_EQ(16, voidfunc20_fake.arg16_val);
504 ASSERT_EQ(17, voidfunc20_fake.arg17_val);
505 ASSERT_EQ(18, voidfunc20_fake.arg18_val);
506 ASSERT_EQ(19, voidfunc20_fake.arg19_val);
507 }
508
509 TEST_F(FFFTestSuite, value_func_can_capture_upto_20_arguments_correctly)
510 {
511 valuefunc20_fake.return_val = 42;
512
513 int return_val = valuefunc20(0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19);
514
515 ASSERT_EQ(42, return_val);
516 ASSERT_EQ(0, valuefunc20_fake.arg0_val);
517 ASSERT_EQ(1, valuefunc20_fake.arg1_val);
518 ASSERT_EQ(2, valuefunc20_fake.arg2_val);
519 ASSERT_EQ(3, valuefunc20_fake.arg3_val);
520 ASSERT_EQ(4, valuefunc20_fake.arg4_val);
521 ASSERT_EQ(5, valuefunc20_fake.arg5_val);
522 ASSERT_EQ(6, valuefunc20_fake.arg6_val);
523 ASSERT_EQ(7, valuefunc20_fake.arg7_val);
524 ASSERT_EQ(8, valuefunc20_fake.arg8_val);
525 ASSERT_EQ(9, valuefunc20_fake.arg9_val);
526 ASSERT_EQ(10, valuefunc20_fake.arg10_val);
527 ASSERT_EQ(11, valuefunc20_fake.arg11_val);
528 ASSERT_EQ(12, valuefunc20_fake.arg12_val);
529 ASSERT_EQ(13, valuefunc20_fake.arg13_val);
530 ASSERT_EQ(14, valuefunc20_fake.arg14_val);
531 ASSERT_EQ(15, valuefunc20_fake.arg15_val);
532 ASSERT_EQ(16, valuefunc20_fake.arg16_val);
533 ASSERT_EQ(17, valuefunc20_fake.arg17_val);
534 ASSERT_EQ(18, valuefunc20_fake.arg18_val);
535 ASSERT_EQ(19, valuefunc20_fake.arg19_val);
536 }
537