Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/testtools/micromock/unittests/micromocktest/micromocktest.cpp

raw
1 // Copyright (c) Microsoft. All rights reserved.
2 // Licensed under the MIT license. See LICENSE file in the project root for full license information.
3
4 #include "stdafx.h"
5 #include "azure_macro_utils/macro_utils.h"
6
7
8 using namespace std;
9
10 DEFINE_MICROMOCK_ENUM_TO_STRING(MICROMOCK_EXCEPTION, MICROMOCK_EXCEPTION_VALUES);
11
12 #define TEST_ORIGINAL_FUNCTION_RESULT (42)
13 #define TEST_MOCK_FUNCTION_RESULT (43)
14
15 void TestFunction()
16 {
17 }
18
19 void StaticTestFunction1()
20 {
21 }
22
23 void StaticTestFunction2()
24 {
25 }
26
27 UINT8 TestFunctionThatReturns42()
28 {
29 return TEST_ORIGINAL_FUNCTION_RESULT;
30 }
31
32 void TestFunctionWithByteArg(UINT8 argument)
33 {
34 UNREFERENCED_PARAMETER(argument);
35 }
36
37 typedef struct TEST_STRUCTURE_TAG
38 {
39 UINT8 m_Value1;
40 UINT32 m_Value2;
41 } TEST_STRUCTURE;
42
43 std::tostringstream& operator<< (std::tostringstream &out, TEST_STRUCTURE const &t)
44 {
45 out << _T("{");
46 out << (unsigned int)t.m_Value1;
47 out << _T(",");
48 out << (unsigned int)t.m_Value2;
49 out << _T("}");
50 return out;
51 }
52
53 static int UINT8_Compare(UINT8 a, UINT8 b)
54 {
55 return (a == b) ? 0 : 1;
56 }
57 static void UINT8_ToString(char* string, size_t bufferSize, UINT8 val)
58 {
59 (void)snprintf(string, bufferSize, "%d", (int)val);
60 }
61
62 /*CTest spec says: tstring_Compare*/
63
64 static int tstring_Compare(const std::tstring& a, const std::tstring&b)
65 {
66 return strcmp(a.c_str(), b.c_str());
67 }
68 static void tstring_ToString(char* string, size_t bufferSize, std::tstring val)
69 {
70 size_t val_size = strlen(val.c_str());
71 strncpy(string, val.c_str(), (val_size >= bufferSize) ? (bufferSize - 1) : val_size);
72 }
73
74 static int bool_Compare(bool a, bool b)
75 {
76 return (a == b) ? 0 : 1;
77 }
78 static void bool_ToString(char* string, size_t bufferSize, bool val)
79 {
80 (void)snprintf(string, bufferSize, "%s", val?"true":"false");
81 }
82
83
84 bool operator==(const TEST_STRUCTURE& lhs, const TEST_STRUCTURE& rhs)
85 {
86 return ((lhs.m_Value1 == rhs.m_Value1) &&
87 (lhs.m_Value2 == rhs.m_Value2));
88 }
89
90 TYPED_MOCK_CLASS(CTestNoMethodsMock, CMock)
91 {
92 };
93
94 TYPED_MOCK_CLASS(CTestNoArgsNoReturnMethodMock, CMock)
95 {
96 public:
97 MOCK_METHOD_0(, void, TestFunction)
98 MOCK_VOID_METHOD_END()
99 };
100
101 #ifdef _MSC_VER
102 TYPED_MOCK_CLASS(CTestStaticNoArgsNoReturnMethodMock, CThreadSafeGlobalMock)
103 {
104 public:
105 MOCK_STATIC_METHOD_0(, void, StaticTestFunction);
106 MOCK_VOID_METHOD_END()
107 };
108 #endif
109
110 #ifdef _MSC_VER
111 TYPED_MOCK_CLASS(CTypedMock, CThreadSafeGlobalMock)
112 {
113 public:
114 MOCK_STATIC_METHOD_1(, void, StaticTestFunctionWithByteArg, UINT8, argument1)
115 MOCK_VOID_METHOD_END()
116 };
117 #endif
118
119 #ifdef _MSC_VER
120 TYPED_MOCK_CLASS(CTestCustomMock, CThreadSafeGlobalMock)
121 {
122 public:
123 MOCK_STATIC_METHOD_1(, UINT8, StaticTestFunction, UINT8, argument1)
124 if (40 == argument1)
125 {
126 return 42;
127 }
128 MOCK_METHOD_END(UINT8, 0)
129 };
130 #endif
131
132 TYPED_MOCK_CLASS(CTestAllArgsMock, CMock)
133 {
134 public:
135 MOCK_METHOD_0(, UINT8, TestFunctionWithNoArgs);
136 MOCK_METHOD_END(UINT8, 0)
137
138 MOCK_METHOD_1(, UINT8, TestFunctionWith1Arg, UINT8, arg1);
139 MOCK_METHOD_END(UINT8, 0)
140
141 MOCK_METHOD_2(, UINT8, TestFunctionWith2Args, UINT8, arg1, UINT8, arg2);
142 MOCK_METHOD_END(UINT8, 0)
143
144 MOCK_METHOD_3(, UINT8, TestFunctionWith3Args, UINT8, arg1, UINT8, arg2, UINT8, arg3);
145 MOCK_METHOD_END(UINT8, 0)
146
147 MOCK_METHOD_4(, UINT8, TestFunctionWith4Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4);
148 MOCK_METHOD_END(UINT8, 0)
149
150 MOCK_METHOD_5(, UINT8, TestFunctionWith5Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4, UINT8, arg5);
151 MOCK_METHOD_END(UINT8, 0)
152
153 MOCK_METHOD_6(, UINT8, TestFunctionWith6Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4, UINT8, arg5, UINT8, arg6);
154 MOCK_METHOD_END(UINT8, 0)
155 };
156
157 static int gInt = 0;
158
159 TYPED_MOCK_CLASS(CTestStaticAllArgsMock, CGlobalMock)
160 {
161 public:
162 MOCK_STATIC_METHOD_0(, UINT8, StaticTestFunctionWithNoArgs);
163 MOCK_METHOD_END(UINT8, 0)
164
165 MOCK_STATIC_METHOD_1(, UINT8, StaticTestFunctionWith1Arg, UINT8, arg1);
166 MOCK_METHOD_END(UINT8, 0)
167
168 MOCK_STATIC_METHOD_1(, UINT8, StaticTestFunctionWith1Arg_Clone, UINT8, arg1);
169 gInt++;
170 MOCK_METHOD_END(UINT8, 0)
171
172 MOCK_STATIC_METHOD_2(, UINT8, StaticTestFunctionWith2Args, UINT8, arg1, UINT8, arg2);
173 MOCK_METHOD_END(UINT8, 0)
174
175 MOCK_STATIC_METHOD_3(, UINT8, StaticTestFunctionWith3Args, UINT8, arg1, UINT8, arg2, UINT8, arg3);
176 MOCK_METHOD_END(UINT8, 0)
177
178 MOCK_STATIC_METHOD_4(, UINT8, StaticTestFunctionWith4Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4);
179 MOCK_METHOD_END(UINT8, 0)
180
181 MOCK_STATIC_METHOD_5(, UINT8, StaticTestFunctionWith5Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4, UINT8, arg5);
182 MOCK_METHOD_END(UINT8, 0)
183
184 MOCK_STATIC_METHOD_6(, UINT8, StaticTestFunctionWith6Args, UINT8, arg1, UINT8, arg2, UINT8, arg3, UINT8, arg4, UINT8, arg5, UINT8, arg6);
185 MOCK_METHOD_END(UINT8, 0)
186 };
187
188 #ifdef _MSC_VER
189 TYPED_MOCK_CLASS(CTestStaticVariousArgsMock, CThreadSafeGlobalMock)
190 {
191 public:
192 MOCK_STATIC_METHOD_1(, UINT8, StaticTestFunctionWithStructArg, TEST_STRUCTURE, testStructure);
193 MOCK_METHOD_END(UINT8, 0)
194
195 MOCK_STATIC_METHOD_1(, UINT8, StaticTestFunctionWithUINT16Arg, UINT16, arg1);
196 MOCK_METHOD_END(UINT8, 0)
197 };
198 #endif
199
200 TYPED_MOCK_CLASS(CTestArgBufferMock, CMock)
201 {
202 public:
203 MOCK_METHOD_1(, void, TestFunction, UINT8*, bufferArg);
204 MOCK_VOID_METHOD_END()
205 };
206
207 #ifdef _MSC_VER
208 TYPED_MOCK_CLASS(CCustomMockCodeNotExecuted, CThreadSafeGlobalMock)
209 {
210 public:
211 MOCK_STATIC_METHOD_0(, UINT8, StaticTestFunction);
212 static UINT8 counter;
213 counter++;
214 MOCK_METHOD_END(UINT8, counter)
215 };
216 #endif
217
218 TYPED_MOCK_CLASS(CSimpleTestMock, CMock)
219 {
220 public:
221 MOCK_METHOD_1(, UINT8, TestFunction, UINT8, arg1);
222 MOCK_METHOD_END(UINT8, 0)
223 };
224
225 TYPED_MOCK_CLASS(CStaticTestMock, CGlobalMock)
226 {
227 public:
228 MOCK_STATIC_METHOD_0(, void, StaticTestFunction);
229 MOCK_VOID_METHOD_END()
230 };
231
232 DECLARE_GLOBAL_MOCK_METHOD_0(CStaticTestMock, , void, StaticTestFunction);
233
234 static MICROMOCK_MUTEX_HANDLE g_testByTest;
235 static MICROMOCK_GLOBAL_SEMAPHORE_HANDLE g_dllByDll;
236
237 BEGIN_TEST_SUITE(MicroMockTest)
238
239 TEST_SUITE_INITIALIZE(TestClassInitialize)
240 {
241 g_testByTest = MicroMockCreateMutex();
242 ASSERT_IS_NOT_NULL(g_testByTest);
243 }
244
245 TEST_SUITE_CLEANUP(TestClassCleanup)
246 {
247 MicroMockDestroyMutex(g_testByTest);
248 }
249
250 TEST_FUNCTION_INITIALIZE(TestMethodInitialize)
251 {
252 if (!MicroMockAcquireMutex(g_testByTest))
253 {
254 ASSERT_FAIL("our mutex is ABANDONED. Failure in test framework");
255 }
256 gInt = 0;
257 }
258
259 TEST_FUNCTION_CLEANUP(TestMethodCleanup)
260 {
261 if (!MicroMockReleaseMutex(g_testByTest))
262 {
263 ASSERT_FAIL("failure in test framework at ReleaseMutex");
264 }
265 }
266
267 tstring BytesToString(UINT8* buffer, size_t bufferLength)
268 {
269 tostringstream strStream;
270
271 strStream << std::uppercase << std::hex;
272
273 strStream << "[";
274
275 for (size_t index = 0; index < bufferLength; index++)
276 {
277 if (index > 0)
278 {
279 strStream << " ";
280 }
281
282 strStream << (unsigned int)buffer[index];
283 }
284
285 strStream << "]";
286
287 return strStream.str();
288 }
289
290 TEST_FUNCTION(MicroMock_Instantiating_A_Mock_With_No_Methods_Succeeds)
291 {
292 // arrange
293
294 // act
295 CTestNoMethodsMock testNoArgsNoReturnMock;
296
297 // assert
298 // no explicit assert, no exception expected
299 }
300
301 TEST_FUNCTION(MicroMock_Creating_A_Mock_Object_Succeeds)
302 {
303 // arrange
304
305 // act
306 CTestNoArgsNoReturnMethodMock testMemoryMock;
307
308 // assert
309 // no explicit assert, no exception expected
310 }
311
312 TEST_FUNCTION(MicroMock_Comparing_Expected_And_Actual_Calls_When_No_Expected_And_Actual_Calls_Are_Made_Returns_No_Mismatch)
313 {
314 // arrange
315 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
316 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
317
318 // act
319 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
320
321 // assert
322 ASSERT_ARE_EQUAL_WITH_MSG(char_ptr, tstring(_T("")).c_str(), result.c_str(),
323 _T("Expected and actual calls do not match"));
324 }
325
326 TEST_FUNCTION(MicroMock_One_Strict_Expected_Call_With_No_Actual_Calls_Indicates_Mismatch)
327 {
328 // arrange
329 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
330 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
331
332 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock, TestFunction());
333
334 // act
335 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
336
337 // assert
338 ASSERT_ARE_EQUAL_WITH_MSG(char_ptr, tstring(_T("[Expected:TestFunction()]")).c_str(), result.c_str() ,
339 _T("Expected and actual calls do not match"));
340 }
341
342 TEST_FUNCTION(MicroMock_Two_Strict_Expected_Calls_With_No_Actual_Calls_Indicates_Mismatch)
343 {
344 // arrange
345 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
346 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
347
348 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock, TestFunction());
349 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock, TestFunction());
350
351 // act
352 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
353
354 // assert
355 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")
356 _T("[Expected:TestFunction()]")), result,
357 _T("Expected and actual calls do not match"));
358 }
359
360 TEST_FUNCTION(MicroMock_One_Strict_Expected_Call_With_No_Actual_Calls_Checked_At_Mock_Level_Indicates_Mismatch)
361 {
362 // arrange
363 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
364 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
365
366 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock, TestFunction());
367
368 // act
369 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
370
371 // assert
372 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")), result,
373 _T("Expected and actual calls do not match"));
374 }
375
376 TEST_FUNCTION(MicroMock_One_On_One_Of_Two_Mocks_When_No_Actual_Calls_Are_Made_Indicates_Mismatch)
377 {
378 // arrange
379 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock1;
380 testNoArgsNoReturnMock1.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
381 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock2;
382 testNoArgsNoReturnMock2.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
383
384 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock1, TestFunction());
385
386 // act
387 tstring result = testNoArgsNoReturnMock1.CompareActualAndExpectedCalls() +
388 testNoArgsNoReturnMock2.CompareActualAndExpectedCalls();
389
390 // assert
391 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")), result,
392 _T("Expected and actual calls do not match"));
393 }
394
395 TEST_FUNCTION(MicroMock_One_Strict_Expected_Call_On_One_Of_Two_Mocks_When_No_Actual_Calls_Are_Made_Indicates_Mismatch)
396 {
397 // arrange
398 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock1;
399 testNoArgsNoReturnMock1.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
400 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock2;
401 testNoArgsNoReturnMock2.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
402
403 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock1, TestFunction());
404
405 // act
406 tstring result = testNoArgsNoReturnMock1.CompareActualAndExpectedCalls() +
407 testNoArgsNoReturnMock2.CompareActualAndExpectedCalls();
408
409 // assert
410 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")), result,
411 _T("Expected and actual calls do not match"));
412 }
413
414 TEST_FUNCTION(MicroMock_One_Strict_Expected_Call_On_Both_Mocks_When_No_Actual_Calls_Are_Made_Indicates_Mismatch)
415 {
416 // arrange
417 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock1;
418 testNoArgsNoReturnMock1.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
419 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock2;
420 testNoArgsNoReturnMock2.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
421
422 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock1, TestFunction());
423 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock2, TestFunction());
424
425 // act
426 tstring result = testNoArgsNoReturnMock1.CompareActualAndExpectedCalls() +
427 testNoArgsNoReturnMock2.CompareActualAndExpectedCalls();
428
429 // assert
430 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")
431 _T("[Expected:TestFunction()]")), result,
432 _T("Expected and actual calls do not match"));
433 }
434
435 TEST_FUNCTION(MicroMock_One_Strict_Expected_Call_And_One_Actual_Call_Indicates_No_Mismatch)
436 {
437 // arrange
438 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
439 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
440
441 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock, TestFunction());
442
443 testNoArgsNoReturnMock.TestFunction();
444
445 // act
446 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
447
448 // assert
449 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result, _T("Expected and actual calls do not match"));
450 }
451
452 TEST_FUNCTION(MicroMock_One_Actual_Call_Without_An_Expected_Call_Indicates_A_Mismatch)
453 {
454 // arrange
455 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock;
456 testNoArgsNoReturnMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
457
458 testNoArgsNoReturnMock.TestFunction();
459
460 // act
461 tstring result = testNoArgsNoReturnMock.CompareActualAndExpectedCalls();
462
463 // assert
464 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction()]")),
465 result, _T("Expected and actual calls do not match"));
466 }
467
468 TEST_FUNCTION(MicroMock_One_Actual_Call_On_A_Different_Mock_Than_The_Expected_Call_Indicates_A_Mismatch)
469 {
470 // arrange
471 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock1;
472 testNoArgsNoReturnMock1.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
473 CTestNoArgsNoReturnMethodMock testNoArgsNoReturnMock2;
474 testNoArgsNoReturnMock2.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
475
476 STRICT_EXPECTED_CALL(testNoArgsNoReturnMock1, TestFunction());
477
478 testNoArgsNoReturnMock2.TestFunction();
479
480 // act
481 tstring result = testNoArgsNoReturnMock1.CompareActualAndExpectedCalls() +
482 testNoArgsNoReturnMock2.CompareActualAndExpectedCalls();
483
484 // assert
485 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction()]")
486 _T("[Actual:TestFunction()]")),
487 result, _T("Expected and actual calls do not match"));
488 }
489
490 #ifdef _MSC_VER
491 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_1_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
492 {
493 // arrange
494 CTestStaticAllArgsMock testMock;
495
496 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith3Args(42, 43, 44));
497
498 CTestStaticAllArgsMock::StaticTestFunctionWith3Args(1, 43, 44);
499
500 // act
501 tstring result = testMock.CompareActualAndExpectedCalls();
502
503 // assert
504 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith3Args(42,43,44)]")
505 _T("[Actual:StaticTestFunctionWith3Args(1,43,44)]")), result,
506 _T("Expected and actual calls do not match"));
507 }
508 #endif
509
510 #ifdef _MSC_VER
511 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_2_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
512 {
513 // arrange
514 CTestStaticAllArgsMock testMock;
515
516 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith3Args(42, 43, 44));
517
518 CTestStaticAllArgsMock::StaticTestFunctionWith3Args(42, 1, 44);
519
520 // act
521 tstring result = testMock.CompareActualAndExpectedCalls();
522
523 // assert
524 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith3Args(42,43,44)]")
525 _T("[Actual:StaticTestFunctionWith3Args(42,1,44)]")), result,
526 _T("Expected and actual calls do not match"));
527 }
528 #endif
529
530 #ifdef _MSC_VER
531 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_3_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
532 {
533 // arrange
534 CTestStaticAllArgsMock testMock;
535
536 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith3Args(42, 43, 44));
537
538 CTestStaticAllArgsMock::StaticTestFunctionWith3Args(42, 43, 1);
539
540 // act
541 tstring result = testMock.CompareActualAndExpectedCalls();
542
543 // assert
544 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith3Args(42,43,44)]")
545 _T("[Actual:StaticTestFunctionWith3Args(42,43,1)]")), result,
546 _T("Expected and actual calls do not match"));
547 }
548 #endif
549
550 #ifdef _MSC_VER
551 TEST_FUNCTION(MicroMockStatic_Method_When_All_3_Args_Match_No_Mismatch_Is_Reported)
552 {
553 // arrange
554 CTestStaticAllArgsMock testMock;
555
556 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith3Args(42, 43, 44));
557
558 CTestStaticAllArgsMock::StaticTestFunctionWith3Args(42, 43, 44);
559
560 // act
561 tstring result = testMock.CompareActualAndExpectedCalls();
562
563 // assert
564 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
565 _T("Expected and actual calls do not match"));
566 }
567 #endif
568
569 #ifdef _MSC_VER
570 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_1_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
571 {
572 // arrange
573 CTestStaticAllArgsMock testMock;
574
575 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith4Args(42, 43, 44, 45));
576
577 CTestStaticAllArgsMock::StaticTestFunctionWith4Args(1, 43, 44, 45);
578
579 // act
580 tstring result = testMock.CompareActualAndExpectedCalls();
581
582 // assert
583 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith4Args(42,43,44,45)]")
584 _T("[Actual:StaticTestFunctionWith4Args(1,43,44,45)]")), result,
585 _T("Expected and actual calls do not match"));
586 }
587 #endif
588
589 #ifdef _MSC_VER
590 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_2_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
591 {
592 // arrange
593 CTestStaticAllArgsMock testMock;
594
595 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith4Args(42, 43, 44, 45));
596
597 CTestStaticAllArgsMock::StaticTestFunctionWith4Args(42, 1, 44, 45);
598
599 // act
600 tstring result = testMock.CompareActualAndExpectedCalls();
601
602 // assert
603 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith4Args(42,43,44,45)]")
604 _T("[Actual:StaticTestFunctionWith4Args(42,1,44,45)]")), result,
605 _T("Expected and actual calls do not match"));
606 }
607 #endif
608
609 #ifdef _MSC_VER
610 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_3_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
611 {
612 // arrange
613 CTestStaticAllArgsMock testMock;
614
615 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith4Args(42, 43, 44, 45));
616
617 CTestStaticAllArgsMock::StaticTestFunctionWith4Args(42, 43, 1, 45);
618
619 // act
620 tstring result = testMock.CompareActualAndExpectedCalls();
621
622 // assert
623 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith4Args(42,43,44,45)]")
624 _T("[Actual:StaticTestFunctionWith4Args(42,43,1,45)]")), result,
625 _T("Expected and actual calls do not match"));
626 }
627 #endif
628
629 #ifdef _MSC_VER
630 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_4_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
631 {
632 // arrange
633 CTestStaticAllArgsMock testMock;
634
635 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith4Args(42, 43, 44, 45));
636
637 CTestStaticAllArgsMock::StaticTestFunctionWith4Args(42, 43, 44, 1);
638
639 // act
640 tstring result = testMock.CompareActualAndExpectedCalls();
641
642 // assert
643 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith4Args(42,43,44,45)]")
644 _T("[Actual:StaticTestFunctionWith4Args(42,43,44,1)]")), result,
645 _T("Expected and actual calls do not match"));
646 }
647 #endif
648
649 #ifdef _MSC_VER
650 TEST_FUNCTION(MicroMockStatic_Method_When_All_4_Args_Match_No_Mismatch_Is_Reported)
651 {
652 // arrange
653 CTestStaticAllArgsMock testMock;
654
655 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith4Args(42, 43, 44, 45));
656
657 CTestStaticAllArgsMock::StaticTestFunctionWith4Args(42, 43, 44, 45);
658
659 // act
660 tstring result = testMock.CompareActualAndExpectedCalls();
661
662 // assert
663 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
664 _T("Expected and actual calls do not match"));
665 }
666 #endif
667
668 #ifdef _MSC_VER
669 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_1_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
670 {
671 // arrange
672 CTestStaticAllArgsMock testMock;
673
674 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
675
676 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(1, 43, 44, 45, 46);
677
678 // act
679 tstring result = testMock.CompareActualAndExpectedCalls();
680
681 // assert
682 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith5Args(42,43,44,45,46)]")
683 _T("[Actual:StaticTestFunctionWith5Args(1,43,44,45,46)]")), result,
684 _T("Expected and actual calls do not match"));
685 }
686 #endif
687
688 #ifdef _MSC_VER
689 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_2_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
690 {
691 // arrange
692 CTestStaticAllArgsMock testMock;
693
694 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
695
696 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(42, 1, 44, 45, 46);
697
698 // act
699 tstring result = testMock.CompareActualAndExpectedCalls();
700
701 // assert
702 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith5Args(42,43,44,45,46)]")
703 _T("[Actual:StaticTestFunctionWith5Args(42,1,44,45,46)]")), result,
704 _T("Expected and actual calls do not match"));
705 }
706 #endif
707
708 #ifdef _MSC_VER
709 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_3_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
710 {
711 // arrange
712 CTestStaticAllArgsMock testMock;
713
714 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
715
716 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(42, 43, 1, 45, 46);
717
718 // act
719 tstring result = testMock.CompareActualAndExpectedCalls();
720
721 // assert
722 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith5Args(42,43,44,45,46)]")
723 _T("[Actual:StaticTestFunctionWith5Args(42,43,1,45,46)]")), result,
724 _T("Expected and actual calls do not match"));
725 }
726 #endif
727
728 #ifdef _MSC_VER
729 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_4_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
730 {
731 // arrange
732 CTestStaticAllArgsMock testMock;
733
734 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
735
736 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(42, 43, 44, 1, 46);
737
738 // act
739 tstring result = testMock.CompareActualAndExpectedCalls();
740
741 // assert
742 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith5Args(42,43,44,45,46)]")
743 _T("[Actual:StaticTestFunctionWith5Args(42,43,44,1,46)]")), result,
744 _T("Expected and actual calls do not match"));
745 }
746 #endif
747
748 #ifdef _MSC_VER
749 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_5_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
750 {
751 // arrange
752 CTestStaticAllArgsMock testMock;
753
754 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
755
756 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(42, 43, 44, 45, 1);
757
758 // act
759 tstring result = testMock.CompareActualAndExpectedCalls();
760
761 // assert
762 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith5Args(42,43,44,45,46)]")
763 _T("[Actual:StaticTestFunctionWith5Args(42,43,44,45,1)]")), result,
764 _T("Expected and actual calls do not match"));
765 }
766 #endif
767
768 #ifdef _MSC_VER
769 TEST_FUNCTION(MicroMockStatic_Method_When_All_5_Args_Match_No_Mismatch_Is_Reported)
770 {
771 // arrange
772 CTestStaticAllArgsMock testMock;
773
774 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith5Args(42, 43, 44, 45, 46));
775
776 CTestStaticAllArgsMock::StaticTestFunctionWith5Args(42, 43, 44, 45, 46);
777
778 // act
779 tstring result = testMock.CompareActualAndExpectedCalls();
780
781 // assert
782 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
783 _T("Expected and actual calls do not match"));
784 }
785 #endif
786
787 #ifdef _MSC_VER
788 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_1_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
789 {
790 // arrange
791 CTestStaticAllArgsMock testMock;
792
793 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
794
795 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(1, 43, 44, 45, 46, 47);
796
797 // act
798 tstring result = testMock.CompareActualAndExpectedCalls();
799
800 // assert
801 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
802 _T("[Actual:StaticTestFunctionWith6Args(1,43,44,45,46,47)]")), result,
803 _T("Expected and actual calls do not match"));
804 }
805 #endif
806
807 #ifdef _MSC_VER
808 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_2_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
809 {
810 // arrange
811 CTestStaticAllArgsMock testMock;
812
813 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
814
815 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 1, 44, 45, 46, 47);
816
817 // act
818 tstring result = testMock.CompareActualAndExpectedCalls();
819
820 // assert
821 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
822 _T("[Actual:StaticTestFunctionWith6Args(42,1,44,45,46,47)]")), result,
823 _T("Expected and actual calls do not match"));
824 }
825 #endif
826
827 #ifdef _MSC_VER
828 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_3_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
829 {
830 // arrange
831 CTestStaticAllArgsMock testMock;
832
833 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
834
835 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 43, 1, 45, 46, 47);
836
837 // act
838 tstring result = testMock.CompareActualAndExpectedCalls();
839
840 // assert
841 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
842 _T("[Actual:StaticTestFunctionWith6Args(42,43,1,45,46,47)]")), result,
843 _T("Expected and actual calls do not match"));
844 }
845 #endif
846
847 #ifdef _MSC_VER
848 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_4_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
849 {
850 // arrange
851 CTestStaticAllArgsMock testMock;
852
853 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
854
855 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 43, 44, 1, 46, 47);
856
857 // act
858 tstring result = testMock.CompareActualAndExpectedCalls();
859
860 // assert
861 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
862 _T("[Actual:StaticTestFunctionWith6Args(42,43,44,1,46,47)]")), result,
863 _T("Expected and actual calls do not match"));
864 }
865 #endif
866
867 #ifdef _MSC_VER
868 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_5_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
869 {
870 // arrange
871 CTestStaticAllArgsMock testMock;
872
873 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
874
875 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 43, 44, 45, 1, 47);
876
877 // act
878 tstring result = testMock.CompareActualAndExpectedCalls();
879
880 // assert
881 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
882 _T("[Actual:StaticTestFunctionWith6Args(42,43,44,45,1,47)]")), result,
883 _T("Expected and actual calls do not match"));
884 }
885 #endif
886
887 #ifdef _MSC_VER
888 TEST_FUNCTION(MicroMockStatic_Method_When_Arg_6_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
889 {
890 // arrange
891 CTestStaticAllArgsMock testMock;
892
893 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
894
895 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 1);
896
897 // act
898 tstring result = testMock.CompareActualAndExpectedCalls();
899
900 // assert
901 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith6Args(42,43,44,45,46,47)]")
902 _T("[Actual:StaticTestFunctionWith6Args(42,43,44,45,46,1)]")), result,
903 _T("Expected and actual calls do not match"));
904 }
905 #endif
906
907 #ifdef _MSC_VER
908 TEST_FUNCTION(MicroMockStatic_Method_When_All_6_Args_Match_No_Mismatch_Is_Reported)
909 {
910 // arrange
911 CTestStaticAllArgsMock testMock;
912
913 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47));
914
915 CTestStaticAllArgsMock::StaticTestFunctionWith6Args(42, 43, 44, 45, 46, 47);
916
917 // act
918 tstring result = testMock.CompareActualAndExpectedCalls();
919
920 // assert
921 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
922 _T("Expected and actual calls do not match"));
923 }
924 #endif
925
926 TEST_FUNCTION(MicroMock_When_Arg_1_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
927 {
928 // arrange
929 CTestAllArgsMock testMock;
930
931 STRICT_EXPECTED_CALL(testMock, TestFunctionWith3Args(42, 43, 44));
932
933 testMock.TestFunctionWith3Args(1, 43, 44);
934
935 // act
936 tstring result = testMock.CompareActualAndExpectedCalls();
937
938 // assert
939 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith3Args(42,43,44)]")
940 _T("[Actual:TestFunctionWith3Args(1,43,44)]")), result,
941 _T("Expected and actual calls do not match"));
942 }
943
944 TEST_FUNCTION(MicroMock_When_Arg_2_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
945 {
946 // arrange
947 CTestAllArgsMock testMock;
948
949 STRICT_EXPECTED_CALL(testMock, TestFunctionWith3Args(42, 43, 44));
950
951 testMock.TestFunctionWith3Args(42, 1, 44);
952
953 // act
954 tstring result = testMock.CompareActualAndExpectedCalls();
955
956 // assert
957 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith3Args(42,43,44)]")
958 _T("[Actual:TestFunctionWith3Args(42,1,44)]")), result,
959 _T("Expected and actual calls do not match"));
960 }
961
962 TEST_FUNCTION(MicroMock_When_Arg_3_Of_3_Is_Mismatched_A_Mismatch_Is_Reported)
963 {
964 // arrange
965 CTestAllArgsMock testMock;
966
967 STRICT_EXPECTED_CALL(testMock, TestFunctionWith3Args(42, 43, 44));
968
969 testMock.TestFunctionWith3Args(42, 43, 1);
970
971 // act
972 tstring result = testMock.CompareActualAndExpectedCalls();
973
974 // assert
975 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith3Args(42,43,44)]")
976 _T("[Actual:TestFunctionWith3Args(42,43,1)]")), result,
977 _T("Expected and actual calls do not match"));
978 }
979
980 TEST_FUNCTION(MicroMock_When_All_3_Args_Match_No_Mismatch_Is_Reported)
981 {
982 // arrange
983 CTestAllArgsMock testMock;
984
985 STRICT_EXPECTED_CALL(testMock, TestFunctionWith3Args(42, 43, 44));
986
987 testMock.TestFunctionWith3Args(42, 43, 44);
988
989 // act
990 tstring result = testMock.CompareActualAndExpectedCalls();
991
992 // assert
993 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
994 _T("Expected and actual calls do not match"));
995 }
996
997 TEST_FUNCTION(MicroMock_When_Arg_1_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
998 {
999 // arrange
1000 CTestAllArgsMock testMock;
1001
1002 STRICT_EXPECTED_CALL(testMock, TestFunctionWith4Args(42, 43, 44, 45));
1003
1004 testMock.TestFunctionWith4Args(1, 43, 44, 45);
1005
1006 // act
1007 tstring result = testMock.CompareActualAndExpectedCalls();
1008
1009 // assert
1010 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith4Args(42,43,44,45)]")
1011 _T("[Actual:TestFunctionWith4Args(1,43,44,45)]")), result,
1012 _T("Expected and actual calls do not match"));
1013 }
1014
1015 TEST_FUNCTION(MicroMock_When_Arg_2_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
1016 {
1017 // arrange
1018 CTestAllArgsMock testMock;
1019
1020 STRICT_EXPECTED_CALL(testMock, TestFunctionWith4Args(42, 43, 44, 45));
1021
1022 testMock.TestFunctionWith4Args(42, 1, 44, 45);
1023
1024 // act
1025 tstring result = testMock.CompareActualAndExpectedCalls();
1026
1027 // assert
1028 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith4Args(42,43,44,45)]")
1029 _T("[Actual:TestFunctionWith4Args(42,1,44,45)]")), result,
1030 _T("Expected and actual calls do not match"));
1031 }
1032
1033 TEST_FUNCTION(MicroMock_When_Arg_3_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
1034 {
1035 // arrange
1036 CTestAllArgsMock testMock;
1037
1038 STRICT_EXPECTED_CALL(testMock, TestFunctionWith4Args(42, 43, 44, 45));
1039
1040 testMock.TestFunctionWith4Args(42, 43, 1, 45);
1041
1042 // act
1043 tstring result = testMock.CompareActualAndExpectedCalls();
1044
1045 // assert
1046 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith4Args(42,43,44,45)]")
1047 _T("[Actual:TestFunctionWith4Args(42,43,1,45)]")), result,
1048 _T("Expected and actual calls do not match"));
1049 }
1050
1051 TEST_FUNCTION(MicroMock_When_Arg_4_Of_4_Is_Mismatched_A_Mismatch_Is_Reported)
1052 {
1053 // arrange
1054 CTestAllArgsMock testMock;
1055
1056 STRICT_EXPECTED_CALL(testMock, TestFunctionWith4Args(42, 43, 44, 45));
1057
1058 testMock.TestFunctionWith4Args(42, 43, 44, 1);
1059
1060 // act
1061 tstring result = testMock.CompareActualAndExpectedCalls();
1062
1063 // assert
1064 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith4Args(42,43,44,45)]")
1065 _T("[Actual:TestFunctionWith4Args(42,43,44,1)]")), result,
1066 _T("Expected and actual calls do not match"));
1067 }
1068
1069 TEST_FUNCTION(MicroMock_When_All_4_Args_Match_No_Mismatch_Is_Reported)
1070 {
1071 // arrange
1072 CTestAllArgsMock testMock;
1073
1074 STRICT_EXPECTED_CALL(testMock, TestFunctionWith4Args(42, 43, 44, 45));
1075
1076 testMock.TestFunctionWith4Args(42, 43, 44, 45);
1077
1078 // act
1079 tstring result = testMock.CompareActualAndExpectedCalls();
1080
1081 // assert
1082 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1083 _T("Expected and actual calls do not match"));
1084 }
1085
1086 TEST_FUNCTION(MicroMock_When_Arg_1_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
1087 {
1088 // arrange
1089 CTestAllArgsMock testMock;
1090
1091 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1092
1093 testMock.TestFunctionWith5Args(1, 43, 44, 45, 46);
1094
1095 // act
1096 tstring result = testMock.CompareActualAndExpectedCalls();
1097
1098 // assert
1099 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith5Args(42,43,44,45,46)]")
1100 _T("[Actual:TestFunctionWith5Args(1,43,44,45,46)]")), result,
1101 _T("Expected and actual calls do not match"));
1102 }
1103
1104 TEST_FUNCTION(MicroMock_When_Arg_2_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
1105 {
1106 // arrange
1107 CTestAllArgsMock testMock;
1108
1109 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1110
1111 testMock.TestFunctionWith5Args(42, 1, 44, 45, 46);
1112
1113 // act
1114 tstring result = testMock.CompareActualAndExpectedCalls();
1115
1116 // assert
1117 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith5Args(42,43,44,45,46)]")
1118 _T("[Actual:TestFunctionWith5Args(42,1,44,45,46)]")), result,
1119 _T("Expected and actual calls do not match"));
1120 }
1121
1122 TEST_FUNCTION(MicroMock_When_Arg_3_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
1123 {
1124 // arrange
1125 CTestAllArgsMock testMock;
1126
1127 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1128
1129 testMock.TestFunctionWith5Args(42, 43, 1, 45, 46);
1130
1131 // act
1132 tstring result = testMock.CompareActualAndExpectedCalls();
1133
1134 // assert
1135 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith5Args(42,43,44,45,46)]")
1136 _T("[Actual:TestFunctionWith5Args(42,43,1,45,46)]")), result,
1137 _T("Expected and actual calls do not match"));
1138 }
1139
1140 TEST_FUNCTION(MicroMock_When_Arg_4_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
1141 {
1142 // arrange
1143 CTestAllArgsMock testMock;
1144
1145 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1146
1147 testMock.TestFunctionWith5Args(42, 43, 44, 1, 46);
1148
1149 // act
1150 tstring result = testMock.CompareActualAndExpectedCalls();
1151
1152 // assert
1153 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith5Args(42,43,44,45,46)]")
1154 _T("[Actual:TestFunctionWith5Args(42,43,44,1,46)]")), result,
1155 _T("Expected and actual calls do not match"));
1156 }
1157
1158 TEST_FUNCTION(MicroMock_When_Arg_5_Of_5_Is_Mismatched_A_Mismatch_Is_Reported)
1159 {
1160 // arrange
1161 CTestAllArgsMock testMock;
1162
1163 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1164
1165 testMock.TestFunctionWith5Args(42, 43, 44, 45, 1);
1166
1167 // act
1168 tstring result = testMock.CompareActualAndExpectedCalls();
1169
1170 // assert
1171 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith5Args(42,43,44,45,46)]")
1172 _T("[Actual:TestFunctionWith5Args(42,43,44,45,1)]")), result,
1173 _T("Expected and actual calls do not match"));
1174 }
1175
1176 TEST_FUNCTION(MicroMock_When_All_5_Args_Match_No_Mismatch_Is_Reported)
1177 {
1178 // arrange
1179 CTestAllArgsMock testMock;
1180
1181 STRICT_EXPECTED_CALL(testMock, TestFunctionWith5Args(42, 43, 44, 45, 46));
1182
1183 testMock.TestFunctionWith5Args(42, 43, 44, 45, 46);
1184
1185 // act
1186 tstring result = testMock.CompareActualAndExpectedCalls();
1187
1188 // assert
1189 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1190 _T("Expected and actual calls do not match"));
1191 }
1192
1193 TEST_FUNCTION(MicroMock_When_Arg_1_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1194 {
1195 // arrange
1196 CTestAllArgsMock testMock;
1197
1198 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1199
1200 testMock.TestFunctionWith6Args(1, 43, 44, 45, 46, 47);
1201
1202 // act
1203 tstring result = testMock.CompareActualAndExpectedCalls();
1204
1205 // assert
1206 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1207 _T("[Actual:TestFunctionWith6Args(1,43,44,45,46,47)]")), result,
1208 _T("Expected and actual calls do not match"));
1209 }
1210
1211 TEST_FUNCTION(MicroMock_When_Arg_2_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1212 {
1213 // arrange
1214 CTestAllArgsMock testMock;
1215
1216 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1217
1218 testMock.TestFunctionWith6Args(42, 1, 44, 45, 46, 47);
1219
1220 // act
1221 tstring result = testMock.CompareActualAndExpectedCalls();
1222
1223 // assert
1224 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1225 _T("[Actual:TestFunctionWith6Args(42,1,44,45,46,47)]")), result,
1226 _T("Expected and actual calls do not match"));
1227 }
1228
1229 TEST_FUNCTION(MicroMock_When_Arg_3_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1230 {
1231 // arrange
1232 CTestAllArgsMock testMock;
1233
1234 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1235
1236 testMock.TestFunctionWith6Args(42, 43, 1, 45, 46, 47);
1237
1238 // act
1239 tstring result = testMock.CompareActualAndExpectedCalls();
1240
1241 // assert
1242 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1243 _T("[Actual:TestFunctionWith6Args(42,43,1,45,46,47)]")), result,
1244 _T("Expected and actual calls do not match"));
1245 }
1246
1247 TEST_FUNCTION(MicroMock_When_Arg_4_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1248 {
1249 // arrange
1250 CTestAllArgsMock testMock;
1251
1252 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1253
1254 testMock.TestFunctionWith6Args(42, 43, 44, 1, 46, 47);
1255
1256 // act
1257 tstring result = testMock.CompareActualAndExpectedCalls();
1258
1259 // assert
1260 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1261 _T("[Actual:TestFunctionWith6Args(42,43,44,1,46,47)]")), result,
1262 _T("Expected and actual calls do not match"));
1263 }
1264
1265 TEST_FUNCTION(MicroMock_When_Arg_5_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1266 {
1267 // arrange
1268 CTestAllArgsMock testMock;
1269
1270 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1271
1272 testMock.TestFunctionWith6Args(42, 43, 44, 45, 1, 47);
1273
1274 // act
1275 tstring result = testMock.CompareActualAndExpectedCalls();
1276
1277 // assert
1278 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1279 _T("[Actual:TestFunctionWith6Args(42,43,44,45,1,47)]")), result,
1280 _T("Expected and actual calls do not match"));
1281 }
1282
1283 TEST_FUNCTION(MicroMock_When_Arg_6_Of_6_Is_Mismatched_A_Mismatch_Is_Reported)
1284 {
1285 // arrange
1286 CTestAllArgsMock testMock;
1287
1288 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1289
1290 testMock.TestFunctionWith6Args(42, 43, 44, 45, 46, 1);
1291
1292 // act
1293 tstring result = testMock.CompareActualAndExpectedCalls();
1294
1295 // assert
1296 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWith6Args(42,43,44,45,46,47)]")
1297 _T("[Actual:TestFunctionWith6Args(42,43,44,45,46,1)]")), result,
1298 _T("Expected and actual calls do not match"));
1299 }
1300
1301 TEST_FUNCTION(MicroMock_When_All_6_Args_Match_No_Mismatch_Is_Reported)
1302 {
1303 // arrange
1304 CTestAllArgsMock testMock;
1305
1306 STRICT_EXPECTED_CALL(testMock, TestFunctionWith6Args(42, 43, 44, 45, 46, 47));
1307
1308 testMock.TestFunctionWith6Args(42, 43, 44, 45, 46, 47);
1309
1310 // act
1311 tstring result = testMock.CompareActualAndExpectedCalls();
1312
1313 // assert
1314 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1315 _T("Expected and actual calls do not match"));
1316 }
1317
1318 #ifdef _MSC_VER
1319 TEST_FUNCTION(MicroMock_When_A_Structure_Is_Used_As_Argument_And_Member_1_Of_2_Is_Different_A_Mismatch_Is_Reported)
1320 {
1321 // arrange
1322 CTestStaticVariousArgsMock testMock;
1323 TEST_STRUCTURE expectedCallArgumentStruct = { 42, 43 };
1324 TEST_STRUCTURE actualCallArgumentStruct = { 1, 43 };
1325
1326 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithStructArg(expectedCallArgumentStruct));
1327
1328 CTestStaticVariousArgsMock::StaticTestFunctionWithStructArg(actualCallArgumentStruct);
1329
1330 // act
1331 tstring result = testMock.CompareActualAndExpectedCalls();
1332
1333 // assert
1334 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWithStructArg({42,43})]")
1335 _T("[Actual:StaticTestFunctionWithStructArg({1,43})]")), result,
1336 _T("Expected and actual calls do not match"));
1337 }
1338 #endif
1339
1340 #ifdef _MSC_VER
1341 TEST_FUNCTION(MicroMock_When_A_Structure_Is_Used_As_Argument_And_Member_2_Of_2_Is_Different_A_Mismatch_Is_Reported)
1342 {
1343 // arrange
1344 CTestStaticVariousArgsMock testMock;
1345 TEST_STRUCTURE expectedCallArgumentStruct = { 42, 43 };
1346 TEST_STRUCTURE actualCallArgumentStruct = { 42, 1 };
1347
1348 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithStructArg(expectedCallArgumentStruct));
1349
1350 CTestStaticVariousArgsMock::StaticTestFunctionWithStructArg(actualCallArgumentStruct);
1351
1352 // act
1353 tstring result = testMock.CompareActualAndExpectedCalls();
1354
1355 // assert
1356 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWithStructArg({42,43})]")
1357 _T("[Actual:StaticTestFunctionWithStructArg({42,1})]")), result,
1358 _T("Expected and actual calls do not match"));
1359 }
1360 #endif
1361
1362 #ifdef _MSC_VER
1363 TEST_FUNCTION(MicroMock_When_A_Structure_Is_Used_As_Argument_And_Members_Match_No_Call_Mismatch_Is_Reported)
1364 {
1365 // arrange
1366 CTestStaticVariousArgsMock testMock;
1367 TEST_STRUCTURE expectedCallArgumentStruct = { 42, 43 };
1368 TEST_STRUCTURE actualCallArgumentStruct = { 42, 43 };
1369
1370 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithStructArg(expectedCallArgumentStruct));
1371
1372 CTestStaticVariousArgsMock::StaticTestFunctionWithStructArg(actualCallArgumentStruct);
1373
1374 // act
1375 tstring result = testMock.CompareActualAndExpectedCalls();
1376
1377 // assert
1378 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1379 _T("Expected and actual calls do not match"));
1380 }
1381 #endif
1382
1383 #ifdef _MSC_VER
1384 TEST_FUNCTION(MicroMock_When_A_Structure_Is_Used_As_Argument_And_Members_Match_But_Filling_Does_Not_No_Call_Mismatch_Is_Reported)
1385 {
1386 // arrange
1387 CTestStaticVariousArgsMock testMock;
1388 TEST_STRUCTURE expectedCallArgumentStruct;
1389 TEST_STRUCTURE actualCallArgumentStruct;
1390
1391 memset(&expectedCallArgumentStruct, 0, sizeof(expectedCallArgumentStruct));
1392 memset(&actualCallArgumentStruct, 0xFF, sizeof(actualCallArgumentStruct));
1393
1394 actualCallArgumentStruct.m_Value1 = expectedCallArgumentStruct.m_Value1 = 42;
1395 actualCallArgumentStruct.m_Value2 = expectedCallArgumentStruct.m_Value2 = 42;
1396
1397 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithStructArg(expectedCallArgumentStruct));
1398
1399 CTestStaticVariousArgsMock::StaticTestFunctionWithStructArg(actualCallArgumentStruct);
1400
1401 // act
1402 tstring result = testMock.CompareActualAndExpectedCalls();
1403
1404 // assert
1405 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1406 _T("Expected and actual calls do not match"));
1407 }
1408 #endif
1409
1410 #ifdef _MSC_VER
1411 TEST_FUNCTION(MicroMock_When_A_UINT16_Is_Used_As_Argument_And_Argument_Values_Match_No_Call_Mismatch_Is_Reported)
1412 {
1413 // arrange
1414 CTestStaticVariousArgsMock testMock;
1415
1416 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithUINT16Arg(4242));
1417
1418 CTestStaticVariousArgsMock::StaticTestFunctionWithUINT16Arg(4242);
1419
1420 // act
1421 tstring result = testMock.CompareActualAndExpectedCalls();
1422
1423 // assert
1424 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1425 _T("Expected and actual calls do not match"));
1426 }
1427 #endif
1428
1429 #ifdef _MSC_VER
1430 TEST_FUNCTION(MicroMock_When_A_UINT16_Is_Used_As_Argument_And_Argument_Values_Do_Not_Match_A_Call_Mismatch_Is_Reported)
1431 {
1432 // arrange
1433 CTestStaticVariousArgsMock testMock;
1434
1435 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWithUINT16Arg(1));
1436
1437 CTestStaticVariousArgsMock::StaticTestFunctionWithUINT16Arg(4242);
1438
1439 // act
1440 tstring result = testMock.CompareActualAndExpectedCalls();
1441
1442 // assert
1443 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWithUINT16Arg(1)][Actual:StaticTestFunctionWithUINT16Arg(4242)]")),
1444 result,
1445 _T("Expected and actual calls do not match"));
1446 }
1447 #endif
1448
1449 #ifdef _MSC_VER
1450 TEST_FUNCTION(MicroMock_Validate_First_Argument_For_Mock_Without_Arguments_Throws)
1451 {
1452 // arrange
1453 CTestStaticNoArgsNoReturnMethodMock testMock;
1454 bool exceptionWasThrown = false;
1455
1456 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
1457
1458 ///act
1459 try
1460 {
1461 EXPECTED_CALL(testMock, StaticTestFunction())
1462 .ValidateArgument(1);
1463 }
1464 catch(CMicroMockException &e)
1465 {
1466 ///assert
1467 exceptionWasThrown=true;
1468 ASSERT_ARE_EQUAL(MICROMOCK_EXCEPTION, MICROMOCK_EXCEPTION_INVALID_ARGUMENT, e.GetMicroMockExceptionCode());
1469 }
1470 catch(...)
1471 {
1472 ASSERT_FAIL(_T("it was expected a CMicroMockException, but something else was thrown"));
1473 }
1474
1475 ASSERT_ARE_EQUAL_WITH_MSG(bool, true, exceptionWasThrown, _T("there was no exception thrown"));
1476
1477 }
1478 #endif
1479
1480 #ifdef _MSC_VER
1481 TEST_FUNCTION(MicroMock_Validating_Argument_Zero_Throws)
1482 {
1483 // arrange
1484 CTestStaticAllArgsMock testMock;
1485 bool exceptionWasThrown = false;
1486
1487 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
1488
1489 try
1490 {
1491 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
1492 .ValidateArgument(0);
1493 }
1494 catch(CMicroMockException &e)
1495 {
1496 ///assert
1497 exceptionWasThrown=true;
1498 ASSERT_ARE_EQUAL(MICROMOCK_EXCEPTION, MICROMOCK_EXCEPTION_INVALID_ARGUMENT, e.GetMicroMockExceptionCode());
1499 }
1500 catch(...)
1501 {
1502 ASSERT_FAIL(_T("it was expected a CMicroMockException, but something else was thrown"));
1503 }
1504
1505 ASSERT_ARE_EQUAL_WITH_MSG(bool, true, exceptionWasThrown, _T("there was no exception thrown"));
1506 }
1507 #endif
1508
1509 #ifdef _MSC_VER
1510 TEST_FUNCTION(MicroMock_Validating_First_Argument_Checks_Expected_vs_Actual)
1511 {
1512 // arrange
1513 CTestStaticAllArgsMock testMock;
1514
1515 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
1516 .ValidateArgument(1);
1517
1518 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(2);
1519
1520 // act
1521 tstring result = testMock.CompareActualAndExpectedCalls();
1522
1523 // assert
1524 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith1Arg(1)]")
1525 _T("[Actual:StaticTestFunctionWith1Arg(2)]")), result,
1526 _T("Expected and actual calls do not match"));
1527 }
1528 #endif
1529
1530 #ifdef _MSC_VER
1531 TEST_FUNCTION(MicroMock_Validating_First_Arg_When_Arg_1_Of_2_Is_Different_Indicates_A_Call_Mismatch)
1532 {
1533 // arrange
1534 CTestStaticAllArgsMock testMock;
1535
1536 EXPECTED_CALL(testMock, StaticTestFunctionWith2Args(42, 43))
1537 .ValidateArgument(1);
1538
1539 CTestStaticAllArgsMock::StaticTestFunctionWith2Args(1, 43);
1540
1541 // act
1542 tstring result = testMock.CompareActualAndExpectedCalls();
1543
1544 // assert
1545 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith2Args(42,43)]")
1546 _T("[Actual:StaticTestFunctionWith2Args(1,43)]")), result,
1547 _T("Expected and actual calls do not match"));
1548 }
1549 #endif
1550
1551 #ifdef _MSC_VER
1552 TEST_FUNCTION(MicroMock_Validating_Second_Arg_When_Arg_2_Of_2_Is_Different_Indicates_A_Call_Mismatch)
1553 {
1554 // arrange
1555 CTestStaticAllArgsMock testMock;
1556
1557 EXPECTED_CALL(testMock, StaticTestFunctionWith2Args(42, 43))
1558 .ValidateArgument(2);
1559
1560 CTestStaticAllArgsMock::StaticTestFunctionWith2Args(42, 1);
1561
1562 // act
1563 tstring result = testMock.CompareActualAndExpectedCalls();
1564
1565 // assert
1566 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith2Args(42,43)]")
1567 _T("[Actual:StaticTestFunctionWith2Args(42,1)]")), result,
1568 _T("Expected and actual calls do not match"));
1569 }
1570 #endif
1571
1572 #ifdef _MSC_VER
1573 TEST_FUNCTION(MicroMock_Validating_First_Arg_When_Arg_2_Of_2_Is_Different_Indicates_No_Call_Mismatch)
1574 {
1575 // arrange
1576 CTestStaticAllArgsMock testMock;
1577
1578 EXPECTED_CALL(testMock, StaticTestFunctionWith2Args(42, 43))
1579 .ValidateArgument(1);
1580
1581 CTestStaticAllArgsMock::StaticTestFunctionWith2Args(42, 1);
1582
1583 // act
1584 tstring result = testMock.CompareActualAndExpectedCalls();
1585
1586 // assert
1587 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1588 _T("Expected and actual calls do not match"));
1589 }
1590 #endif
1591
1592 #ifdef _MSC_VER
1593 TEST_FUNCTION(MicroMock_WhenCalled_Strict_Verifies_Arguments)
1594 {
1595 // arrange
1596 CTestStaticAllArgsMock testMock;
1597 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
1598
1599 WHEN_CALLED_STRICT(testMock, StaticTestFunctionWith1Arg(42))
1600 .SetReturn((UINT8)42);
1601
1602 // act
1603 UINT8 result = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(43);
1604
1605 // assert
1606 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)0, result, _T("Incorrect result value"));
1607 }
1608 #endif
1609
1610 #ifdef _MSC_VER
1611 TEST_FUNCTION(MicroMock_WhenCalled_Strict_Gets_Correct_Return_Value_When_Arguments_Match)
1612 {
1613 // arrange
1614 CTestStaticAllArgsMock testMock;
1615 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
1616
1617 WHEN_CALLED_STRICT(testMock, StaticTestFunctionWith1Arg(42))
1618 .SetReturn((UINT8)42);
1619
1620 // act
1621 UINT8 result = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1622
1623 // assert
1624 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)42, result, _T("Incorrect result value"));
1625 }
1626 #endif
1627
1628 #ifdef _MSC_VER
1629 TEST_FUNCTION(MicroMock_Non_Strict_WhenCalled_Ignores_Arguments)
1630 {
1631 // arrange
1632 CTestStaticAllArgsMock testMock;
1633 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
1634
1635 WHEN_CALLED(testMock, StaticTestFunctionWith1Arg(42))
1636 .SetReturn((UINT8)42);
1637
1638 // act
1639 UINT8 result = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(43);
1640
1641 // assert
1642 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)42, result, _T("Incorrect result value"));
1643 }
1644 #endif
1645
1646 #ifdef _MSC_VER
1647 TEST_FUNCTION(MicroMock_ResetExpectedCalls_Without_Any_Expected_Calls_Does_Nothing)
1648 {
1649 // arrange
1650 CTestStaticAllArgsMock testMock;
1651
1652 testMock.ResetExpectedCalls();
1653
1654 // act
1655 tstring result = testMock.CompareActualAndExpectedCalls();
1656
1657 // assert
1658 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1659 _T("Expected and actual calls do not match"));
1660 }
1661 #endif
1662
1663 #ifdef _MSC_VER
1664 TEST_FUNCTION(MicroMock_ResetExpectedCalls_Clears_The_List_Of_Expected_Calls)
1665 {
1666 // arrange
1667 CTestStaticAllArgsMock testMock;
1668
1669 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1670
1671 testMock.ResetExpectedCalls();
1672
1673 // act
1674 tstring result = testMock.CompareActualAndExpectedCalls();
1675
1676 // assert
1677 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1678 _T("Expected and actual calls do not match"));
1679 }
1680 #endif
1681
1682 #ifdef _MSC_VER
1683 TEST_FUNCTION(MicroMock_ResetExpectedCalls_With_One_Expected_And_One_Actual_Call_Reports_A_Call_Mismatch)
1684 {
1685 // arrange
1686 CTestStaticAllArgsMock testMock;
1687
1688 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1689
1690 testMock.ResetExpectedCalls();
1691 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1692
1693 // act
1694 tstring result = testMock.CompareActualAndExpectedCalls();
1695
1696 // assert
1697 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:StaticTestFunctionWith1Arg(42)]")), result,
1698 _T("Expected and actual calls do not match"));
1699 }
1700 #endif
1701
1702 #ifdef _MSC_VER
1703 TEST_FUNCTION(MicroMock_2_Consecutive_ResetExpectedCalls_Clear_The_Expected_Calls)
1704 {
1705 // arrange
1706 CTestStaticAllArgsMock testMock;
1707
1708 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1709
1710 testMock.ResetExpectedCalls();
1711 testMock.ResetExpectedCalls();
1712
1713 // act
1714 tstring result = testMock.CompareActualAndExpectedCalls();
1715
1716 // assert
1717 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1718 _T("Expected and actual calls do not match"));
1719 }
1720 #endif
1721
1722 #ifdef _MSC_VER
1723 TEST_FUNCTION(MicroMock_2_ResetExpectedCalls_Each_After_One_Expected_Call_Clear_The_Expected_Calls_List)
1724 {
1725 // arrange
1726 CTestStaticAllArgsMock testMock;
1727
1728 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1729 testMock.ResetExpectedCalls();
1730
1731 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1732 testMock.ResetExpectedCalls();
1733
1734 // act
1735 tstring result = testMock.CompareActualAndExpectedCalls();
1736
1737 // assert
1738 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1739 _T("Expected and actual calls do not match"));
1740 }
1741 #endif
1742
1743 #ifdef _MSC_VER
1744 TEST_FUNCTION(MicroMock_After_A_ResetExpectedCalls_It_Is_Possible_To_Set_Expectations)
1745 {
1746 // arrange
1747 CTestStaticAllArgsMock testMock;
1748
1749 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1750 testMock.ResetExpectedCalls();
1751
1752 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1753 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1754
1755 // act
1756 tstring result = testMock.CompareActualAndExpectedCalls();
1757
1758 // assert
1759 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1760 _T("Expected and actual calls do not match"));
1761 }
1762 #endif
1763
1764 #ifdef _MSC_VER
1765 TEST_FUNCTION(MicroMock_ResetExpectedCalls_Clears_2_Expected_Calls)
1766 {
1767 // arrange
1768 CTestStaticAllArgsMock testMock;
1769
1770 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1771 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1772 testMock.ResetExpectedCalls();
1773
1774 // act
1775 tstring result = testMock.CompareActualAndExpectedCalls();
1776
1777 // assert
1778 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1779 _T("Expected and actual calls do not match"));
1780 }
1781 #endif
1782
1783 #ifdef _MSC_VER
1784 TEST_FUNCTION(MicroMock_ResetActualCalls_Without_Any_Actual_Calls_Does_Nothing)
1785 {
1786 // arrange
1787 CTestStaticAllArgsMock testMock;
1788
1789 testMock.ResetActualCalls();
1790
1791 // act
1792 tstring result = testMock.CompareActualAndExpectedCalls();
1793
1794 // assert
1795 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1796 _T("Expected and actual calls do not match"));
1797 }
1798 #endif
1799
1800 #ifdef _MSC_VER
1801 TEST_FUNCTION(MicroMock_ResetActualCalls_Clears_The_List_Of_Actual_Calls)
1802 {
1803 // arrange
1804 CTestStaticAllArgsMock testMock;
1805
1806 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1807 testMock.ResetActualCalls();
1808
1809 // act
1810 tstring result = testMock.CompareActualAndExpectedCalls();
1811
1812 // assert
1813 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1814 _T("Expected and actual calls do not match"));
1815 }
1816 #endif
1817
1818 #ifdef _MSC_VER
1819 TEST_FUNCTION(MicroMock_ResetActualCalls_With_One_Expected_And_One_Actual_Call_Reports_A_Call_Mismatch)
1820 {
1821 // arrange
1822 CTestStaticAllArgsMock testMock;
1823
1824 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1825
1826 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1827 testMock.ResetActualCalls();
1828
1829 // act
1830 tstring result = testMock.CompareActualAndExpectedCalls();
1831
1832 // assert
1833 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:StaticTestFunctionWith1Arg(42)]")), result,
1834 _T("Expected and actual calls do not match"));
1835 }
1836 #endif
1837
1838 #ifdef _MSC_VER
1839 TEST_FUNCTION(MicroMock_2_Consecutive_ResetActualCalls_Clear_The_Actual_Calls)
1840 {
1841 // arrange
1842 CTestStaticAllArgsMock testMock;
1843
1844 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1845 testMock.ResetActualCalls();
1846 testMock.ResetActualCalls();
1847
1848 // act
1849 tstring result = testMock.CompareActualAndExpectedCalls();
1850
1851 // assert
1852 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1853 _T("Expected and actual calls do not match"));
1854 }
1855 #endif
1856
1857 #ifdef _MSC_VER
1858 TEST_FUNCTION(MicroMock_2_ResetActualCalls_Each_After_One_Actual_Call_Clear_The_Actual_Calls_List)
1859 {
1860 // arrange
1861 CTestStaticAllArgsMock testMock;
1862
1863 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1864 testMock.ResetActualCalls();
1865
1866 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1867 testMock.ResetActualCalls();
1868
1869 // act
1870 tstring result = testMock.CompareActualAndExpectedCalls();
1871
1872 // assert
1873 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1874 _T("Expected and actual calls do not match"));
1875 }
1876 #endif
1877
1878 #ifdef _MSC_VER
1879 TEST_FUNCTION(MicroMock_After_A_ResetActualCalls_It_Is_Possible_To_Set_Expectations)
1880 {
1881 // arrange
1882 CTestStaticAllArgsMock testMock;
1883
1884 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1885 testMock.ResetActualCalls();
1886
1887 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1888 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1889
1890 // act
1891 tstring result = testMock.CompareActualAndExpectedCalls();
1892
1893 // assert
1894 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1895 _T("Expected and actual calls do not match"));
1896 }
1897 #endif
1898
1899 #ifdef _MSC_VER
1900 TEST_FUNCTION(MicroMock_ResetActualCalls_Clears_2_Actual_Calls)
1901 {
1902 // arrange
1903 CTestStaticAllArgsMock testMock;
1904
1905 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1906 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1907 testMock.ResetActualCalls();
1908
1909 // act
1910 tstring result = testMock.CompareActualAndExpectedCalls();
1911
1912 // assert
1913 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1914 _T("Expected and actual calls do not match"));
1915 }
1916 #endif
1917
1918 #ifdef _MSC_VER
1919 TEST_FUNCTION(MicroMock_ResetAllCalls_Clears_Expected_Calls)
1920 {
1921 // arrange
1922 CTestStaticAllArgsMock testMock;
1923
1924 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(42));
1925 testMock.ResetAllCalls();
1926
1927 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1928
1929 // act
1930 tstring result = testMock.CompareActualAndExpectedCalls();
1931
1932 // assert
1933 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:StaticTestFunctionWith1Arg(42)]")), result,
1934 _T("Expected and actual calls do not match"));
1935 }
1936 #endif
1937
1938 #ifdef _MSC_VER
1939 TEST_FUNCTION(MicroMock_ResetAllCalls_Clears_Both_Actual_And_Expected_Calls)
1940 {
1941 // arrange
1942 CTestStaticAllArgsMock testMock;
1943
1944 EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(43));
1945 CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(42);
1946 testMock.ResetAllCalls();
1947
1948 // act
1949 tstring result = testMock.CompareActualAndExpectedCalls();
1950
1951 // assert
1952 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
1953 _T("Expected and actual calls do not match"));
1954 }
1955 #endif
1956
1957 #ifdef _MSC_VER
1958 TEST_FUNCTION(MicroMock_TypedMock_Instantiation_Succeeds)
1959 {
1960 // arrange
1961
1962 // act
1963 CTypedMock testMock;
1964
1965 // assert
1966 }
1967 #endif
1968
1969 #ifdef _MSC_VER
1970 TEST_FUNCTION(MicroMock_Custom_Mocks_Execute_The_Mock_Method_Code)
1971 {
1972 // arrange
1973 CTestCustomMock testMock;
1974
1975 EXPECTED_CALL(testMock, StaticTestFunction(40));
1976
1977 // act
1978 UINT8 result = CTestCustomMock::StaticTestFunction(40);
1979
1980 // assert
1981 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)42, result, _T("The custom mock code should get executed"));
1982 }
1983 #endif
1984
1985 #ifdef _MSC_VER
1986 TEST_FUNCTION(MicroMock_ExpectedCall_Does_Not_Execute_Custom_Mock_Code)
1987 {
1988 // arrange
1989 CCustomMockCodeNotExecuted testMock;
1990
1991 EXPECTED_CALL(testMock, StaticTestFunction());
1992
1993 // act
1994 UINT8 result = CCustomMockCodeNotExecuted::StaticTestFunction();
1995
1996 // assert
1997 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)1, result, _T("The custom code in the mock should only be called once"));
1998 }
1999 #endif
2000
2001 TEST_FUNCTION(MicroMock_Instantiating_A_Mock_Method_With_An_Out_Argument_Succeeds)
2002 {
2003 // arrange
2004
2005 // act
2006 CTestArgBufferMock testMock;
2007
2008 // assert
2009 // no explicit assert, no exception expected
2010 }
2011
2012 TEST_FUNCTION(MicroMock_Instantiating_A_Mock_With_Strict_Ordered_Call_Comparer_Succeeds)
2013 {
2014 // arrange
2015
2016 // act
2017 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2018
2019 // assert
2020 // no explicit assert, no exception expected
2021 }
2022
2023 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_With_Only_One_Expected_Call_Indicates_Call_Mismatch)
2024 {
2025 // arrange
2026 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2027
2028 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2029
2030 // act
2031 tstring result = testMock.CompareActualAndExpectedCalls();
2032
2033 // assert
2034 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction(42)]")), result,
2035 _T("Expected and actual calls do not match"));
2036 }
2037
2038 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_With_Only_One_Actual_Call_Indicates_Call_Mismatch)
2039 {
2040 // arrange
2041 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2042
2043 testMock.TestFunction(42);
2044
2045 // act
2046 tstring result = testMock.CompareActualAndExpectedCalls();
2047
2048 // assert
2049 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(42)]")), result,
2050 _T("Expected and actual calls do not match"));
2051 }
2052
2053 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_With_One_Expected_Call_And_An_Actual_Call_Indicates_No_Call_Mismatches)
2054 {
2055 // arrange
2056 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2057
2058 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2059 testMock.TestFunction(42);
2060
2061 // act
2062 tstring result = testMock.CompareActualAndExpectedCalls();
2063
2064 // assert
2065 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
2066 _T("Expected and actual calls do not match"));
2067 }
2068
2069 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_With_An_Extra_Expected_Call_Before_2_Matching_Calls_Indicates_Mismatch)
2070 {
2071 // arrange
2072 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2073
2074 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2075 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2076 testMock.TestFunction(42);
2077
2078 // act
2079 tstring result = testMock.CompareActualAndExpectedCalls();
2080
2081 // assert
2082 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction(41)][Expected:TestFunction(42)][Actual:TestFunction(42)]")), result,
2083 _T("Expected and actual calls do not match"));
2084 }
2085
2086 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_With_An_Extra_Expected_Call_After_2_Matching_Calls_Indicates_Mismatch)
2087 {
2088 // arrange
2089 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2090
2091 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2092 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2093 testMock.TestFunction(42);
2094
2095 // act
2096 tstring result = testMock.CompareActualAndExpectedCalls();
2097
2098 // assert
2099 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction(41)]")), result,
2100 _T("Expected and actual calls do not match"));
2101 }
2102
2103 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Between_2_Matching_Calls_Indicates_Mismatch)
2104 {
2105 // arrange
2106 CStrictOrderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2107
2108 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2109 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2110 STRICT_EXPECTED_CALL(testMock, TestFunction(43));
2111 testMock.TestFunction(41);
2112 testMock.TestFunction(43);
2113
2114 // act
2115 tstring result = testMock.CompareActualAndExpectedCalls();
2116
2117 // assert
2118 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunction(42)][Expected:TestFunction(43)]")
2119 _T("[Actual:TestFunction(43)]")), result,
2120 _T("Expected and actual calls do not match"));
2121 }
2122
2123 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_One_Extra_Actual_Call_Indicates_Mismatch)
2124 {
2125 // arrange
2126 CStrictOrderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2127
2128 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2129 testMock.TestFunction(41);
2130 testMock.TestFunction(43);
2131
2132 // act
2133 tstring result = testMock.CompareActualAndExpectedCalls();
2134
2135 // assert
2136 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(43)]")), result,
2137 _T("Expected and actual calls do not match"));
2138 }
2139
2140 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Ignores_A_When_Called_Entry_Before_All_Expected_Calls)
2141 {
2142 // arrange
2143 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2144
2145 WHEN_CALLED(testMock, TestFunction(41))
2146 .SetReturn((UINT8)42);
2147 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2148 testMock.TestFunction(41);
2149
2150 // act
2151 tstring result = testMock.CompareActualAndExpectedCalls();
2152
2153 // assert
2154 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
2155 _T("Expected and actual calls do not match"));
2156 }
2157
2158 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Ignores_A_When_Called_Entry_In_The_Middle_Of_Other_Expetced_Calls)
2159 {
2160 // arrange
2161 CStrictOrderedCallComparer<CSimpleTestMock> testMock;
2162
2163 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2164 WHEN_CALLED(testMock, TestFunction(43))
2165 .SetReturn((UINT8)42);
2166 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2167 testMock.TestFunction(41);
2168 testMock.TestFunction(42);
2169
2170 // act
2171 tstring result = testMock.CompareActualAndExpectedCalls();
2172
2173 // assert
2174 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
2175 _T("Expected and actual calls do not match"));
2176 }
2177
2178 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Ignores_A_When_Called_Entry_After_All_Expected_Calls)
2179 {
2180 // arrange
2181 CSimpleTestMock testMock;
2182
2183 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2184 STRICT_EXPECTED_CALL(testMock, TestFunction(42));
2185 WHEN_CALLED(testMock, TestFunction(43))
2186 .SetReturn((UINT8)42);
2187 testMock.TestFunction(41);
2188 testMock.TestFunction(42);
2189
2190 // act
2191 tstring result = testMock.CompareActualAndExpectedCalls();
2192
2193 // assert
2194 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), result,
2195 _T("Expected and actual calls do not match"));
2196 }
2197
2198 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Uses_When_Called_Entries)
2199 {
2200 // arrange
2201 CSimpleTestMock testMock;
2202 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2203
2204 WHEN_CALLED(testMock, TestFunction(43))
2205 .SetReturn((UINT8)1);
2206
2207 // act
2208 UINT8 result = testMock.TestFunction(43);
2209
2210 // assert
2211 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)1, result,
2212 _T("Incorrect result injected by the mock"));
2213 }
2214
2215 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Uses_When_Called_Entries_Even_When_Other_Expeted_Calls_Exist)
2216 {
2217 // arrange
2218 CStrictOrderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2219
2220 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2221 WHEN_CALLED(testMock, TestFunction(43))
2222 .SetReturn((UINT8)1);
2223
2224 // act
2225 UINT8 result = testMock.TestFunction(43);
2226
2227 // assert
2228 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)1, result,
2229 _T("Incorrect result injected by the mock"));
2230 }
2231
2232 TEST_FUNCTION(MicroMock_Resetting_Expected_Calls_With_1_Actual_Call_Does_Clears_The_Matching_Of_Actual_Calls)
2233 {
2234 // arrange
2235 CSimpleTestMock testMock;
2236 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2237
2238 STRICT_EXPECTED_CALL(testMock, TestFunction(41));
2239 testMock.TestFunction(41);
2240
2241 // act
2242 testMock.ResetExpectedCalls();
2243
2244 // assert
2245 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(41)]")), testMock.CompareActualAndExpectedCalls(),
2246 _T("Expected and actual calls do not match"));
2247 }
2248
2249 TEST_FUNCTION(MicroMock_Nice_Call_Comparer_With_Automcatic_Comparison_Off_Can_Be_Instantiated)
2250 {
2251 // arrange
2252
2253 // act
2254 CNiceCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2255
2256 // assert
2257 // no explicit assert
2258 }
2259
2260 TEST_FUNCTION(MicroMock_StrictUnordered_Call_Comparer_With_Automcatic_Comparison_Off_Can_Be_Instantiated)
2261 {
2262 // arrange
2263
2264 // act
2265 CStrictUnorderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2266
2267 // assert
2268 // no explicit assert
2269 }
2270
2271 TEST_FUNCTION(MicroMock_StrictOrdered_Call_Comparer_With_Automcatic_Comparison_Off_Can_Be_Instantiated)
2272 {
2273 // arrange
2274
2275 // act
2276 CStrictOrderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2277
2278 // assert
2279 // no explicit assert
2280 }
2281
2282 TEST_FUNCTION(MicroMock_StrictOrderedCallComparer_Last_When_Called_Data_Is_Used_When_Multiple_Entries_Are_Available)
2283 {
2284 // arrange
2285 CStrictOrderedCallComparer<CSimpleTestMock> testMock(AUTOMATIC_CALL_COMPARISON_OFF);
2286
2287 WHEN_CALLED(testMock, TestFunction(42))
2288 .SetReturn((UINT8)42);
2289 WHEN_CALLED(testMock, TestFunction(42))
2290 .SetReturn((UINT8)43);
2291
2292 // act
2293 UINT8 result = testMock.TestFunction(42);
2294
2295 // assert
2296 ASSERT_ARE_EQUAL_WITH_MSG(UINT8, (UINT8)43, result, _T("Incorrect result injected by the mock"));
2297 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(42)]")), testMock.CompareActualAndExpectedCalls(),
2298 _T("Expected and actual calls do not match"));
2299 }
2300
2301 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_Zero_Argument_Index_Does_Nothing)
2302 {
2303 // arrange
2304 CTestArgBufferMock testMock;
2305 UINT8 injectedOutBuffer[1] = {0x42};
2306 UINT8 actualArgumentBuffer[1] = {0};
2307
2308 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2309 .CopyOutArgumentBuffer(0, injectedOutBuffer, sizeof(injectedOutBuffer));
2310
2311 // act
2312 testMock.TestFunction(actualArgumentBuffer);
2313
2314 // assert
2315 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[0]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2316 _T("No out argument buffer content should be copied"));
2317 ASSERT_ARE_NOT_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2318 _T("Incorrect calls"));
2319 }
2320
2321 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_Argument_Index_Out_Of_Bounds_Does_Nothing)
2322 {
2323 // arrange
2324 CTestArgBufferMock testMock;
2325 UINT8 injectedOutBuffer[1] = {0x42};
2326 UINT8 actualArgumentBuffer[1] = {0};
2327
2328 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2329 .CopyOutArgumentBuffer(2, injectedOutBuffer, sizeof(injectedOutBuffer));
2330
2331 // act
2332 testMock.TestFunction(actualArgumentBuffer);
2333
2334 // assert
2335 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[0]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2336 _T("No out argument buffer content should be copied"));
2337 ASSERT_ARE_NOT_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2338 _T("Incorrect calls"));
2339 }
2340
2341 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_1_Byte_Payload_Copies_1_Byte)
2342 {
2343 // arrange
2344 CTestArgBufferMock testMock;
2345 UINT8 injectedOutBuffer[1] = {0x42};
2346 UINT8 actualArgumentBuffer[1] = {0};
2347
2348 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2349 .CopyOutArgumentBuffer(1, injectedOutBuffer, sizeof(injectedOutBuffer));
2350
2351 // act
2352 testMock.TestFunction(actualArgumentBuffer);
2353
2354 // assert
2355 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[42]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2356 _T("1 byte of out argument buffer should be injected"));
2357 }
2358
2359 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_NULL_Buffer_Throws)
2360 {
2361 // arrange
2362 CTestArgBufferMock testMock;
2363 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2364
2365 MICROMOCK_EXCEPTION exceptionCode = MICROMOCK_EXCEPTION_INTERNAL_ERROR; // anything that is different than the expected code
2366
2367 try
2368 {
2369 // act
2370 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2371 .CopyOutArgumentBuffer(1, NULL, 1);
2372 }
2373 catch (CMicroMockException e)
2374 {
2375 exceptionCode = e.GetMicroMockExceptionCode();
2376 }
2377
2378 // assert
2379 ASSERT_ARE_EQUAL_WITH_MSG(int, (int)MICROMOCK_EXCEPTION_INVALID_ARGUMENT, (int)exceptionCode,
2380 _T("Expected an invalid argument exception"));
2381 }
2382
2383 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_Zero_Byte_Count_Throws)
2384 {
2385 // arrange
2386 CTestArgBufferMock testMock;
2387 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2388
2389 UINT8 injectedOutBuffer[1] = {0x42};
2390 MICROMOCK_EXCEPTION exceptionCode = MICROMOCK_EXCEPTION_INTERNAL_ERROR; // anything that is different than the expected code
2391
2392 try
2393 {
2394 // act
2395 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2396 .CopyOutArgumentBuffer(1, injectedOutBuffer, 0);
2397 }
2398 catch (CMicroMockException e)
2399 {
2400 exceptionCode = e.GetMicroMockExceptionCode();
2401 }
2402
2403 // assert
2404 ASSERT_ARE_EQUAL_WITH_MSG(int, (int)MICROMOCK_EXCEPTION_INVALID_ARGUMENT, (int)exceptionCode,
2405 _T("Expected an invalid argument exception"));
2406 }
2407
2408 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_Only_First_Byte_Out_Of_2_Bytes_Is_Copied)
2409 {
2410 // arrange
2411 CTestArgBufferMock testMock;
2412 UINT8 injectedOutBuffer[2] = {0x42, 0x42};
2413 UINT8 actualArgumentBuffer[2] = {0, 0};
2414
2415 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2416 .CopyOutArgumentBuffer(1, injectedOutBuffer, 1);
2417
2418 // act
2419 testMock.TestFunction(actualArgumentBuffer);
2420
2421 // assert
2422 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[42 0]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2423 _T("Only the first byte should be copied"));
2424 }
2425
2426 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_With_Offset_1_Copies_Starting_At_Offset_1)
2427 {
2428 // arrange
2429 CTestArgBufferMock testMock;
2430 UINT8 injectedOutBuffer[2] = {0x42, 0x42};
2431 UINT8 actualArgumentBuffer[2] = {0, 0};
2432
2433 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2434 .CopyOutArgumentBuffer(1, injectedOutBuffer, 1, 1);
2435
2436 // act
2437 testMock.TestFunction(actualArgumentBuffer);
2438
2439 // assert
2440 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[0 42]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2441 _T("Only the second byte should be copied"));
2442 }
2443
2444 TEST_FUNCTION(MicroMock_CopyOutArgumentBuffer_Makes_A_Copy_Of_The_Expected_Buffer)
2445 {
2446 // arrange
2447 CTestArgBufferMock testMock;
2448 UINT8 injectedArgumentBuffer[1] = {0x42};
2449 UINT8 actualArgumentBuffer[1] = {0};
2450
2451 STRICT_EXPECTED_CALL(testMock, TestFunction(NULL))
2452 .CopyOutArgumentBuffer(1, injectedArgumentBuffer, sizeof(injectedArgumentBuffer));
2453
2454 injectedArgumentBuffer[0] = 0x41;
2455
2456 // act
2457 testMock.TestFunction(actualArgumentBuffer);
2458
2459 // assert
2460 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[42]")), BytesToString(actualArgumentBuffer, sizeof(actualArgumentBuffer)),
2461 _T("The initial expected injected buffer contents should be copied"));
2462 }
2463
2464 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Strict_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
2465 {
2466 // arrange
2467 CTestAllArgsMock testMock;
2468 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2469
2470 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2471 .ExpectedTimesExactly(1);
2472
2473 // act
2474 testMock.TestFunctionWithNoArgs();
2475
2476 // assert
2477 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2478 _T("Incorrect calls"));
2479 }
2480
2481 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Strict_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
2482 {
2483 // arrange
2484 CTestAllArgsMock testMock;
2485 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2486
2487 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2488 .ExpectedTimesExactly(1);
2489
2490 // act
2491
2492 // assert
2493 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2494 _T("Incorrect calls"));
2495 }
2496
2497 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Strict_Comparer_When_Actual_Call_Is_Made_Yields_Mismatch)
2498 {
2499 // arrange
2500 CTestAllArgsMock testMock;
2501 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2502
2503 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2504 .ExpectedTimesExactly(0);
2505
2506 // act
2507 testMock.TestFunctionWithNoArgs();
2508
2509 // assert
2510 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2511 _T("Incorrect calls"));
2512 }
2513
2514 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Strict_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
2515 {
2516 // arrange
2517 CTestAllArgsMock testMock;
2518 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
2519
2520 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2521 .ExpectedTimesExactly(0);
2522
2523 // act
2524
2525 // assert
2526 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2527 _T("Incorrect calls"));
2528 }
2529
2530 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Times_With_Strict_Comparer_When_2_Actual_Calls_Are_Made_Yields_Mismatch)
2531 {
2532 // arrange
2533 CTestAllArgsMock testMock;
2534
2535 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2536 .ExpectedTimesExactly(1);
2537
2538 testMock.TestFunctionWithNoArgs();
2539
2540 // act
2541 testMock.TestFunctionWithNoArgs();
2542
2543 // assert
2544 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2545 _T("Incorrect calls"));
2546 }
2547
2548 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
2549 {
2550 // arrange
2551 CTestAllArgsMock testMock;
2552
2553 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2554 .ExpectedTimesExactly(2);
2555
2556 // act
2557 testMock.TestFunctionWithNoArgs();
2558
2559 // assert
2560 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2561 _T("Incorrect calls"));
2562 }
2563
2564 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
2565 {
2566 // arrange
2567 CTestAllArgsMock testMock;
2568
2569 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2570 .ExpectedTimesExactly(2);
2571
2572 testMock.TestFunctionWithNoArgs();
2573
2574 // act
2575 testMock.TestFunctionWithNoArgs();
2576
2577 // assert
2578 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2579 _T("Incorrect calls"));
2580 }
2581
2582 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
2583 {
2584 // arrange
2585 CTestAllArgsMock testMock;
2586
2587 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2588 .ExpectedTimesExactly(2);
2589
2590 // act
2591
2592 // assert
2593 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
2594 _T("Incorrect calls"));
2595 }
2596
2597 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Strict_Ordered_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
2598 {
2599 // arrange
2600 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2601
2602 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2603 .ExpectedTimesExactly(1);
2604
2605 // act
2606 testMock.TestFunctionWithNoArgs();
2607
2608 // assert
2609 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2610 _T("Incorrect calls"));
2611 }
2612
2613 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Strict_Ordered_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
2614 {
2615 // arrange
2616 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2617
2618 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2619 .ExpectedTimesExactly(1);
2620
2621 // act
2622
2623 // assert
2624 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2625 _T("Incorrect calls"));
2626 }
2627
2628 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Strict_Ordered_Comparer_When_Actual_Call_Is_Made_Yields_Mismatch)
2629 {
2630 // arrange
2631 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2632
2633 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2634 .ExpectedTimesExactly(0);
2635
2636 // act
2637 testMock.TestFunctionWithNoArgs();
2638
2639 // assert
2640 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2641 _T("Incorrect calls"));
2642 }
2643
2644 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Strict_Ordered_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
2645 {
2646 // arrange
2647 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2648
2649 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2650 .ExpectedTimesExactly(0);
2651
2652 // act
2653
2654 // assert
2655 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2656 _T("Incorrect calls"));
2657 }
2658
2659 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Times_With_Strict_Ordered_Comparer_When_2_Actual_Calls_Are_Made_Yields_Mismatch)
2660 {
2661 // arrange
2662 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2663
2664 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2665 .ExpectedTimesExactly(1);
2666
2667 testMock.TestFunctionWithNoArgs();
2668
2669 // act
2670 testMock.TestFunctionWithNoArgs();
2671
2672 // assert
2673 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2674 _T("Incorrect calls"));
2675 }
2676
2677 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Ordered_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
2678 {
2679 // arrange
2680 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2681
2682 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2683 .ExpectedTimesExactly(2);
2684
2685 // act
2686 testMock.TestFunctionWithNoArgs();
2687
2688 // assert
2689 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2690 _T("Incorrect calls"));
2691 }
2692
2693 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Ordered_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
2694 {
2695 // arrange
2696 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2697
2698 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2699 .ExpectedTimesExactly(2);
2700
2701 testMock.TestFunctionWithNoArgs();
2702
2703 // act
2704 testMock.TestFunctionWithNoArgs();
2705
2706 // assert
2707 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2708 _T("Incorrect calls"));
2709 }
2710
2711 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Strict_Ordered_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
2712 {
2713 // arrange
2714 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2715
2716 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2717 .ExpectedTimesExactly(2);
2718
2719 // act
2720
2721 // assert
2722 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
2723 _T("Incorrect calls"));
2724 }
2725
2726 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Nice_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
2727 {
2728 // arrange
2729 CNiceCallComparer<CTestAllArgsMock> testMock;
2730
2731 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2732 .ExpectedTimesExactly(1);
2733
2734 // act
2735 testMock.TestFunctionWithNoArgs();
2736
2737 // assert
2738 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2739 _T("Incorrect calls"));
2740 }
2741
2742 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Time_With_Nice_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
2743 {
2744 // arrange
2745 CNiceCallComparer<CTestAllArgsMock> testMock;
2746
2747 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2748 .ExpectedTimesExactly(1);
2749
2750 // act
2751
2752 // assert
2753 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2754 _T("Incorrect calls"));
2755 }
2756
2757 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Nice_Comparer_When_Actual_Call_Is_Made_Yields_Mismatch)
2758 {
2759 // arrange
2760 CNiceCallComparer<CTestAllArgsMock> testMock;
2761
2762 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2763 .ExpectedTimesExactly(0);
2764
2765 // act
2766 testMock.TestFunctionWithNoArgs();
2767
2768 // assert
2769 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2770 _T("Incorrect calls"));
2771 }
2772
2773 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_Zero_Times_With_Nice_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
2774 {
2775 // arrange
2776 CNiceCallComparer<CTestAllArgsMock> testMock;
2777
2778 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2779 .ExpectedTimesExactly(0);
2780
2781 // act
2782
2783 // assert
2784 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2785 _T("Incorrect calls"));
2786 }
2787
2788 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_One_Times_With_Nice_Comparer_When_2_Actual_Calls_Are_Made_Yields_Mismatch)
2789 {
2790 // arrange
2791 CNiceCallComparer<CTestAllArgsMock> testMock;
2792
2793 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2794 .ExpectedTimesExactly(1);
2795
2796 testMock.TestFunctionWithNoArgs();
2797
2798 // act
2799 testMock.TestFunctionWithNoArgs();
2800
2801 // assert
2802 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2803 _T("Incorrect calls"));
2804 }
2805
2806 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Nice_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
2807 {
2808 // arrange
2809 CNiceCallComparer<CTestAllArgsMock> testMock;
2810
2811 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2812 .ExpectedTimesExactly(2);
2813
2814 // act
2815 testMock.TestFunctionWithNoArgs();
2816
2817 // assert
2818 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2819 _T("Incorrect calls"));
2820 }
2821
2822 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Nice_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
2823 {
2824 // arrange
2825 CNiceCallComparer<CTestAllArgsMock> testMock;
2826
2827 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2828 .ExpectedTimesExactly(2);
2829
2830 testMock.TestFunctionWithNoArgs();
2831
2832 // act
2833 testMock.TestFunctionWithNoArgs();
2834
2835 // assert
2836 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2837 _T("Incorrect calls"));
2838 }
2839
2840 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_2_Times_With_Nice_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
2841 {
2842 // arrange
2843 CNiceCallComparer<CTestAllArgsMock> testMock;
2844
2845 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2846 .ExpectedTimesExactly(2);
2847
2848 // act
2849
2850 // assert
2851 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
2852 _T("Incorrect calls"));
2853 }
2854
2855 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Strict_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
2856 {
2857 // arrange
2858 CTestAllArgsMock testMock;
2859
2860 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2861 .ExpectedAtLeastTimes(1);
2862
2863 // act
2864 testMock.TestFunctionWithNoArgs();
2865
2866 // assert
2867 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2868 _T("Incorrect calls"));
2869 }
2870
2871 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Strict_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
2872 {
2873 // arrange
2874 CTestAllArgsMock testMock;
2875
2876 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2877 .ExpectedAtLeastTimes(1);
2878
2879 // act
2880
2881 // assert
2882 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2883 _T("Incorrect calls"));
2884 }
2885
2886 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Strict_Comparer_When_Actual_Call_Is_Made_Yields_Mismatch)
2887 {
2888 // arrange
2889 CTestAllArgsMock testMock;
2890
2891 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2892 .ExpectedAtLeastTimes(0);
2893
2894 // act
2895 testMock.TestFunctionWithNoArgs();
2896
2897 // assert
2898 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2899 _T("Incorrect calls"));
2900 }
2901
2902 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Strict_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
2903 {
2904 // arrange
2905 CTestAllArgsMock testMock;
2906
2907 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2908 .ExpectedAtLeastTimes(0);
2909
2910 // act
2911
2912 // assert
2913 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2914 _T("Incorrect calls"));
2915 }
2916
2917 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Times_With_Strict_Comparer_When_2_Actual_Calls_Are_Made_Yields_Mismatch)
2918 {
2919 // arrange
2920 CTestAllArgsMock testMock;
2921
2922 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2923 .ExpectedAtLeastTimes(1);
2924
2925 testMock.TestFunctionWithNoArgs();
2926
2927 // act
2928 testMock.TestFunctionWithNoArgs();
2929
2930 // assert
2931 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2932 _T("Incorrect calls"));
2933 }
2934
2935 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
2936 {
2937 // arrange
2938 CTestAllArgsMock testMock;
2939
2940 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2941 .ExpectedAtLeastTimes(2);
2942
2943 // act
2944 testMock.TestFunctionWithNoArgs();
2945
2946 // assert
2947 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
2948 _T("Incorrect calls"));
2949 }
2950
2951 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
2952 {
2953 // arrange
2954 CTestAllArgsMock testMock;
2955
2956 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2957 .ExpectedAtLeastTimes(2);
2958
2959 testMock.TestFunctionWithNoArgs();
2960
2961 // act
2962 testMock.TestFunctionWithNoArgs();
2963
2964 // assert
2965 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2966 _T("Incorrect calls"));
2967 }
2968
2969 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
2970 {
2971 // arrange
2972 CTestAllArgsMock testMock;
2973
2974 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2975 .ExpectedAtLeastTimes(2);
2976
2977 // act
2978
2979 // assert
2980 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
2981 _T("Incorrect calls"));
2982 }
2983
2984 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Strict_Ordered_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
2985 {
2986 // arrange
2987 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
2988
2989 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
2990 .ExpectedAtLeastTimes(1);
2991
2992 // act
2993 testMock.TestFunctionWithNoArgs();
2994
2995 // assert
2996 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
2997 _T("Incorrect calls"));
2998 }
2999
3000 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Strict_Ordered_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
3001 {
3002 // arrange
3003 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3004
3005 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3006 .ExpectedAtLeastTimes(1);
3007
3008 // act
3009
3010 // assert
3011 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3012 _T("Incorrect calls"));
3013 }
3014
3015 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Strict_Ordered_Comparer_When_Actual_Call_Is_Made_Yields_Mismatch)
3016 {
3017 // arrange
3018 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3019
3020 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3021 .ExpectedAtLeastTimes(0);
3022
3023 // act
3024 testMock.TestFunctionWithNoArgs();
3025
3026 // assert
3027 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3028 _T("Incorrect calls"));
3029 }
3030
3031 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Strict_Ordered_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
3032 {
3033 // arrange
3034 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3035
3036 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3037 .ExpectedAtLeastTimes(0);
3038
3039 // act
3040
3041 // assert
3042 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3043 _T("Incorrect calls"));
3044 }
3045
3046 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Times_With_Strict_Ordered_Comparer_When_2_Actual_Calls_Are_Made_Yields_Mismatch)
3047 {
3048 // arrange
3049 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3050
3051 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3052 .ExpectedAtLeastTimes(1);
3053
3054 testMock.TestFunctionWithNoArgs();
3055
3056 // act
3057 testMock.TestFunctionWithNoArgs();
3058
3059 // assert
3060 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3061 _T("Incorrect calls"));
3062 }
3063
3064 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Ordered_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
3065 {
3066 // arrange
3067 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3068
3069 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3070 .ExpectedAtLeastTimes(2);
3071
3072 // act
3073 testMock.TestFunctionWithNoArgs();
3074
3075 // assert
3076 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3077 _T("Incorrect calls"));
3078 }
3079
3080 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Ordered_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
3081 {
3082 // arrange
3083 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3084
3085 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3086 .ExpectedAtLeastTimes(2);
3087
3088 testMock.TestFunctionWithNoArgs();
3089
3090 // act
3091 testMock.TestFunctionWithNoArgs();
3092
3093 // assert
3094 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3095 _T("Incorrect calls"));
3096 }
3097
3098 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Strict_Ordered_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3099 {
3100 // arrange
3101 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3102
3103 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3104 .ExpectedAtLeastTimes(2);
3105
3106 // act
3107
3108 // assert
3109 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
3110 _T("Incorrect calls"));
3111 }
3112
3113 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Nice_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
3114 {
3115 // arrange
3116 CNiceCallComparer<CTestAllArgsMock> testMock;
3117
3118 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3119 .ExpectedAtLeastTimes(1);
3120
3121 // act
3122 testMock.TestFunctionWithNoArgs();
3123
3124 // assert
3125 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3126 _T("Incorrect calls"));
3127 }
3128
3129 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Time_With_Nice_Comparer_When_No_Actual_Call_Is_Made_Yields_Mismatch)
3130 {
3131 // arrange
3132 CNiceCallComparer<CTestAllArgsMock> testMock;
3133
3134 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3135 .ExpectedAtLeastTimes(1);
3136
3137 // act
3138
3139 // assert
3140 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3141 _T("Incorrect calls"));
3142 }
3143
3144 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Nice_Comparer_When_Actual_Call_Is_Made_Yields_No_Mismatch)
3145 {
3146 // arrange
3147 CNiceCallComparer<CTestAllArgsMock> testMock;
3148
3149 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3150 .ExpectedAtLeastTimes(0);
3151
3152 // act
3153 testMock.TestFunctionWithNoArgs();
3154
3155 // assert
3156 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3157 _T("Incorrect calls"));
3158 }
3159
3160 TEST_FUNCTION(MicroMock_ExpectedTimes_Zero_Times_With_Nice_Comparer_When_No_Actual_Call_Is_Made_Yields_No_Mismatch)
3161 {
3162 // arrange
3163 CNiceCallComparer<CTestAllArgsMock> testMock;
3164
3165 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3166 .ExpectedAtLeastTimes(0);
3167
3168 // act
3169
3170 // assert
3171 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3172 _T("Incorrect calls"));
3173 }
3174
3175 TEST_FUNCTION(MicroMock_ExpectedTimes_One_Times_With_Nice_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
3176 {
3177 // arrange
3178 CNiceCallComparer<CTestAllArgsMock> testMock;
3179
3180 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3181 .ExpectedAtLeastTimes(1);
3182
3183 testMock.TestFunctionWithNoArgs();
3184
3185 // act
3186 testMock.TestFunctionWithNoArgs();
3187
3188 // assert
3189 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3190 _T("Incorrect calls"));
3191 }
3192
3193 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Nice_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
3194 {
3195 // arrange
3196 CNiceCallComparer<CTestAllArgsMock> testMock;
3197
3198 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3199 .ExpectedAtLeastTimes(2);
3200
3201 // act
3202 testMock.TestFunctionWithNoArgs();
3203
3204 // assert
3205 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3206 _T("Incorrect calls"));
3207 }
3208
3209 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Nice_Comparer_When_2_Actual_Calls_Are_Made_Yields_No_Mismatch)
3210 {
3211 // arrange
3212 CNiceCallComparer<CTestAllArgsMock> testMock;
3213
3214 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3215 .ExpectedAtLeastTimes(2);
3216
3217 testMock.TestFunctionWithNoArgs();
3218
3219 // act
3220 testMock.TestFunctionWithNoArgs();
3221
3222 // assert
3223 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3224 _T("Incorrect calls"));
3225 }
3226
3227 TEST_FUNCTION(MicroMock_ExpectedTimes_2_Times_With_Nice_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3228 {
3229 // arrange
3230 CNiceCallComparer<CTestAllArgsMock> testMock;
3231
3232 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3233 .ExpectedAtLeastTimes(2);
3234
3235 // act
3236
3237 // assert
3238 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()](x2)")), testMock.CompareActualAndExpectedCalls(),
3239 _T("Incorrect calls"));
3240 }
3241
3242 TEST_FUNCTION(MicroMock_ExpectedTimes_1_Times_On_2_Different_Calls_With_Strict_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3243 {
3244 // arrange
3245 CTestAllArgsMock testMock;
3246
3247 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3248 .ExpectedAtLeastTimes(1);
3249 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3250 .ExpectedAtLeastTimes(1);
3251
3252 // act
3253
3254 // assert
3255 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3256 _T("Incorrect calls"));
3257 }
3258
3259 TEST_FUNCTION(MicroMock_ExpectedTimes_1_Times_On_2_Different_Calls_With_Strict_Ordered_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3260 {
3261 // arrange
3262 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3263
3264 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3265 .ExpectedAtLeastTimes(1);
3266 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3267 .ExpectedAtLeastTimes(1);
3268
3269 // act
3270
3271 // assert
3272 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3273 _T("Incorrect calls"));
3274 }
3275
3276 TEST_FUNCTION(MicroMock_ExpectedTimes_1_Times_On_2_Different_Calls_With_Nice_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3277 {
3278 // arrange
3279 CNiceCallComparer<CTestAllArgsMock> testMock;
3280
3281 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3282 .ExpectedAtLeastTimes(1);
3283 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3284 .ExpectedAtLeastTimes(1);
3285
3286 // act
3287
3288 // assert
3289 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3290 _T("Incorrect calls"));
3291 }
3292
3293 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Strict_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3294 {
3295 // arrange
3296 CTestAllArgsMock testMock;
3297
3298 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3299 .ExpectedTimesExactly(1);
3300 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3301 .ExpectedTimesExactly(1);
3302
3303 // act
3304
3305 // assert
3306 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3307 _T("Incorrect calls"));
3308 }
3309
3310 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Strict_Ordered_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3311 {
3312 // arrange
3313 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3314
3315 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3316 .ExpectedTimesExactly(1);
3317 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3318 .ExpectedTimesExactly(1);
3319
3320 // act
3321
3322 // assert
3323 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3324 _T("Incorrect calls"));
3325 }
3326
3327 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Nice_Comparer_When_No_Actual_Calls_Are_Made_Yields_Mismatch)
3328 {
3329 // arrange
3330 CNiceCallComparer<CTestAllArgsMock> testMock;
3331
3332 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3333 .ExpectedTimesExactly(1);
3334 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3335 .ExpectedTimesExactly(1);
3336
3337 // act
3338
3339 // assert
3340 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()][Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3341 _T("Incorrect calls"));
3342 }
3343
3344 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Strict_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
3345 {
3346 // arrange
3347 CTestAllArgsMock testMock;
3348
3349 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3350 .ExpectedTimesExactly(1);
3351 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3352 .ExpectedTimesExactly(1);
3353
3354 // act
3355 testMock.TestFunctionWithNoArgs();
3356
3357 // assert
3358 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3359 _T("Incorrect calls"));
3360 }
3361
3362 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Strict_Ordered_Comparer_When_1_Actual_Call_Is_Made_Yields_Mismatch)
3363 {
3364 // arrange
3365 CStrictOrderedCallComparer<CTestAllArgsMock> testMock;
3366
3367 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3368 .ExpectedTimesExactly(1);
3369 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3370 .ExpectedTimesExactly(1);
3371
3372 // act
3373 testMock.TestFunctionWithNoArgs();
3374
3375 // assert
3376 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3377 _T("Incorrect calls"));
3378 }
3379
3380 TEST_FUNCTION(MicroMock_ExpectedTimesExactly_1_Times_On_2_Different_Calls_With_Nice_Comparer_When_1_Actual_Calls_Is_Made_Yields_Mismatch)
3381 {
3382 // arrange
3383 CNiceCallComparer<CTestAllArgsMock> testMock;
3384
3385 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3386 .ExpectedTimesExactly(1);
3387 STRICT_EXPECTED_CALL(testMock, TestFunctionWithNoArgs())
3388 .ExpectedTimesExactly(1);
3389
3390 // act
3391 testMock.TestFunctionWithNoArgs();
3392
3393 // assert
3394 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Expected:TestFunctionWithNoArgs()]")), testMock.CompareActualAndExpectedCalls(),
3395 _T("Incorrect calls"));
3396 }
3397
3398 TEST_FUNCTION(MicroMock_Validating_Argument_Buffer_Zero_Throws)
3399 {
3400 // arrange
3401 CTestArgBufferMock testMock;
3402 UINT8 someRealUINT8=7;
3403 bool exceptionWasThrown = false;
3404
3405 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
3406
3407 try
3408 {
3409 EXPECTED_CALL(testMock, TestFunction(IGNORED_PTR_ARG))
3410 .ValidateArgumentBuffer(0, &someRealUINT8, 1);
3411 }
3412 catch(CMicroMockException &e)
3413 {
3414 ///assert
3415 exceptionWasThrown=true;
3416 ASSERT_ARE_EQUAL(int, (int)MICROMOCK_EXCEPTION_INVALID_ARGUMENT, (int)e.GetMicroMockExceptionCode());
3417 }
3418 catch(...)
3419 {
3420 ASSERT_FAIL(_T("it was expected a CMicroMockException, but something else was thrown"));
3421 }
3422
3423 ASSERT_ARE_EQUAL_WITH_MSG(bool, true, exceptionWasThrown, _T("there was no exception thrown"));
3424 }
3425
3426 TEST_FUNCTION(MicroMock_Validating_Argument_Buffer_With_Too_Big_Argument_Number_Throws)
3427 {
3428 // arrange
3429 CTestArgBufferMock testMock;
3430 UINT8 someRealUINT8=7;
3431 bool exceptionWasThrown=false;
3432
3433 testMock.SetPerformAutomaticCallComparison(AUTOMATIC_CALL_COMPARISON_OFF);
3434
3435 try
3436 {
3437 EXPECTED_CALL(testMock, TestFunction(IGNORED_PTR_ARG))
3438 .ValidateArgumentBuffer(2, &someRealUINT8, 1); /*2 is too big here*/
3439 }
3440 catch(CMicroMockException &e)
3441 {
3442 ///assert
3443 exceptionWasThrown=true;
3444 ASSERT_ARE_EQUAL(int, (int)MICROMOCK_EXCEPTION_INVALID_ARGUMENT, (int)e.GetMicroMockExceptionCode());
3445 }
3446 catch(...)
3447 {
3448 ASSERT_FAIL(_T("it was expected a CMicroMockException, but something else was thrown"));
3449 }
3450
3451 ASSERT_ARE_EQUAL_WITH_MSG(bool, true, exceptionWasThrown, _T("there was no exception thrown"));
3452
3453 }
3454
3455 TEST_FUNCTION(MicroMock_Ignores_A_Certain_FunctionCall_All_The_Time)
3456 {
3457 // arrange
3458 CStaticTestMock testMock;
3459
3460 EXPECTED_CALL(testMock, StaticTestFunction())
3461 .IgnoreAllCalls();
3462
3463 StaticTestFunction();
3464 StaticTestFunction();
3465
3466 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3467 _T("Incorrect calls"));
3468 }
3469
3470 TEST_FUNCTION(MicroMock_Ignores_A_Certain_FunctionCall_All_The_Time_With_Ordered_Call_Comparer)
3471 {
3472 // arrange
3473 CStrictOrderedCallComparer<CStaticTestMock> testMock;
3474
3475 EXPECTED_CALL(testMock, StaticTestFunction())
3476 .IgnoreAllCalls();
3477
3478 StaticTestFunction();
3479 StaticTestFunction();
3480
3481 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3482 _T("Incorrect calls"));
3483 }
3484
3485 TEST_FUNCTION(MicroMock_Does_Not_Check_Again_Calls_That_Have_Been_Matched)
3486 {
3487 // arrange
3488 CTestArgBufferMock testMock;
3489 unsigned char expectedArgumentBuffer[] = { 0x42 };
3490 unsigned char actualArgumentBuffer[] = { 0x42 };
3491
3492 EXPECTED_CALL(testMock, TestFunction(IGNORED_PTR_ARG))
3493 .ValidateArgumentBuffer(1, expectedArgumentBuffer, sizeof(expectedArgumentBuffer));
3494
3495 testMock.TestFunction(actualArgumentBuffer);
3496 testMock.TestFunction(NULL);
3497
3498 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(NULL)]")), testMock.CompareActualAndExpectedCalls(),
3499 _T("Incorrect calls"));
3500 }
3501
3502 TEST_FUNCTION(MicroMock_Does_Not_Check_Again_Calls_That_Have_Been_Matched_StrictOrderedComparer)
3503 {
3504 // arrange
3505 CStrictOrderedCallComparer<CTestArgBufferMock> testMock;
3506 unsigned char expectedArgumentBuffer[] = { 0x42 };
3507 unsigned char actualArgumentBuffer[] = { 0x42 };
3508
3509 EXPECTED_CALL(testMock, TestFunction(IGNORED_PTR_ARG))
3510 .ValidateArgumentBuffer(1, expectedArgumentBuffer, sizeof(expectedArgumentBuffer));
3511
3512 testMock.TestFunction(actualArgumentBuffer);
3513 testMock.TestFunction(NULL);
3514
3515 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("[Actual:TestFunction(NULL)]")), testMock.CompareActualAndExpectedCalls(),
3516 _T("Incorrect calls"));
3517 }
3518
3519 TEST_FUNCTION(MicroMock_Does_Not_Check_Again_Calls_That_Have_Been_Matched_NiceCallComparer)
3520 {
3521 // arrange
3522 CNiceCallComparer<CTestArgBufferMock> testMock;
3523 unsigned char expectedArgumentBuffer[] = { 0x42 };
3524 unsigned char actualArgumentBuffer[] = { 0x42 };
3525
3526 EXPECTED_CALL(testMock, TestFunction(IGNORED_PTR_ARG))
3527 .ValidateArgumentBuffer(1, expectedArgumentBuffer, sizeof(expectedArgumentBuffer));
3528
3529 testMock.TestFunction(actualArgumentBuffer);
3530 testMock.TestFunction(NULL);
3531
3532 ASSERT_ARE_EQUAL_WITH_MSG(tstring, tstring(_T("")), testMock.CompareActualAndExpectedCalls(),
3533 _T("Incorrect calls"));
3534 }
3535
3536 TEST_FUNCTION(MicroMock_SetFailReturn_called_1_times_returns_fail_value)
3537 {
3538
3539 ///arrange
3540 CTestStaticAllArgsMock testMock;
3541
3542 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
3543 .ValidateArgument(1)
3544 .SetFailReturn((UINT8)3);
3545
3546 ///act
3547 int result = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(1);
3548
3549 /// assert
3550 ASSERT_ARE_EQUAL(int, 3, result);
3551 testMock.AssertActualAndExpectedCalls();
3552 }
3553
3554 TEST_FUNCTION(MicroMock_SetFailReturn_called_2_times_with_fail_at_two_succeeds)
3555 {
3556
3557 ///arrange
3558 CTestStaticAllArgsMock testMock;
3559
3560 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
3561 .ValidateArgument(1);
3562
3563 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
3564 .ValidateArgument(1)
3565 .SetFailReturn((UINT8)3);
3566
3567 ///act
3568 int result1 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(1);
3569 int result2 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(1);
3570
3571 /// assert
3572 ASSERT_ARE_EQUAL(int, 0, result1);
3573 ASSERT_ARE_EQUAL(int, 3, result2);
3574 testMock.AssertActualAndExpectedCalls();
3575 }
3576
3577 TEST_FUNCTION(MicroMock_SetFailReturn_called_2_times_with_fail_at_one_succeeds)
3578 {
3579
3580 ///arrange
3581 CTestStaticAllArgsMock testMock;
3582
3583 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
3584 .ValidateArgument(1)
3585 .SetFailReturn((UINT8)3);
3586
3587 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg(1))
3588 .ValidateArgument(1);
3589
3590
3591 ///act
3592 int result1 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(1);
3593 int result2 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg(1);
3594
3595 /// assert
3596 ASSERT_ARE_EQUAL(int, 3, result1);
3597 ASSERT_ARE_EQUAL(int, 0, result2);
3598 testMock.AssertActualAndExpectedCalls();
3599 }
3600
3601 TEST_FUNCTION(MicroMock_SetFailReturn_does_not_execute_the_mock_code)
3602 {
3603
3604 ///arrange
3605 CTestStaticAllArgsMock testMock;
3606
3607 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg_Clone(1))
3608 .SetFailReturn((UINT8)3);
3609
3610 ///act
3611 int result1 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg_Clone(1);
3612
3613 /// assert
3614 ASSERT_ARE_EQUAL(int, 3, result1);
3615 ASSERT_ARE_EQUAL(int, 0, gInt);
3616 testMock.AssertActualAndExpectedCalls();
3617 }
3618
3619 TEST_FUNCTION(MicroMock_SetReturn_does_execute_the_mock_code)
3620 {
3621
3622 ///arrange
3623 CTestStaticAllArgsMock testMock;
3624
3625 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg_Clone(1))
3626 .SetReturn((UINT8)3);
3627
3628 ///act
3629 int result1 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg_Clone(1);
3630
3631 /// assert
3632 ASSERT_ARE_EQUAL(int, 3, result1);
3633 ASSERT_ARE_EQUAL(int, 1, gInt);
3634 testMock.AssertActualAndExpectedCalls();
3635 }
3636
3637 TEST_FUNCTION(MicroMock_SetReturn_does_execute_the_mock_code_and_SetFailDoesNotExecuteMockCode)
3638 {
3639
3640 ///arrange
3641 CTestStaticAllArgsMock testMock;
3642
3643 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg_Clone(1))
3644 .SetReturn((UINT8)3);
3645
3646 STRICT_EXPECTED_CALL(testMock, StaticTestFunctionWith1Arg_Clone(1))
3647 .SetFailReturn((UINT8)5);
3648
3649
3650 ///act
3651 int result1 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg_Clone(1);
3652 int result2 = CTestStaticAllArgsMock::StaticTestFunctionWith1Arg_Clone(1);
3653
3654 /// assert
3655 ASSERT_ARE_EQUAL(int, 3, result1);
3656 ASSERT_ARE_EQUAL(int, 5, result2);
3657 ASSERT_ARE_EQUAL(int, 1, gInt);
3658 testMock.AssertActualAndExpectedCalls();
3659
3660 }
3661
3662 END_TEST_SUITE(MicroMockTest)
3663