Debian Codegraph @

src/vendor/azure-uamqp-c/deps/azure-c-shared-utility/testtools/micromock/inc/timediscretemicromock.h

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 /*defines*/
5 #ifndef TIME_DISCRETE_MICRO_MOCK_H
6 #define TIME_DISCRETE_MICRO_MOCK_H
7
8 #pragma once
9
10 #include "stdafx.h"
11 #include "micromock.h"
12
13 typedef unsigned int UINT32;
14
15 #define TD_MOCK_CLASS(className) \
16 class Typed_##className; \
17 typedef CTimeDiscreteMicroMock<Typed_##className> className; \
18 TYPED_MOCK_CLASS(Typed_##className, CThreadSafeGlobalMock)
19
20 // A strict expected call implies that all arguments are checked
21 #define STRICT_EXPECTED_CALL_AT(ClassName, time, ...) \
22 STRICT_EXPECTED_CALL(ClassName, __VA_ARGS__) \
23 .AddExtraCallArgument(new CMockCallArgument<UINT32>(time, false))
24
25
26
27 // By using the below macro, none of the arguments are checked by default
28 // To specify checking the argument values, use the ValidateArgument
29 // expected call modifier method
30 #define EXPECTED_CALL_AT(ClassName, time, ...) \
31 STRICT_EXPECTED_CALL_AT(ClassName, time, __VA_ARGS__) \
32 .IgnoreAllArguments()
33
34 /*this macro takes a mock name, looks it up in the repository, and gets the time provider for that mock*/
35 #define MOCK_TIMEPROVIDER(mockName) \
36 (dynamic_cast<CTimeDiscreteMicroMockBase*>(GetSingleton())->getCurrentTick())
37
38
39
40
41
42 /*a poor interface that says "I know how to play"*/
43 class canPlay
44 {
45 public:
46 virtual void PlayTick(_In_ UINT32 time, _In_ UINT32 order)=0;
47 virtual ~canPlay()=0;
48 };
49
50 inline canPlay::~canPlay(){}
51
52 template <typename T> class valueHolder
53 {
54 private:
55 T theValue;
56 public:
57 valueHolder(_In_ const T& t)
58 {
59 theValue = t;
60 }
61
62 void operator=(_In_ T& t)
63 {
64 theValue = t;
65 }
66
67 operator T*(void)
68 {
69 return &theValue;
70 }
71
72 operator T&(void)
73 {
74 return theValue;
75 }
76
77 void setArraySize(_In_ size_t size)
78 {
79 UNREFERENCED_PARAMETER(size);
80 ASSERT_FAIL("Setting an array size for something that is not a pointer is CATASTROPHIC failure");
81 }
82 };
83
84 /*template template parameter partial specialization, or something*/
85 template <typename T> class valueHolder <T*>
86 {
87 private:
88 bool wasNULL;
89
90 T theValue;
91
92 T* originalPointer;
93 T* copyArray;
94 size_t arraySize;
95
96 private:
97 void SetValue(_In_ T* t)
98 {
99 if(t==NULL)
100 {
101 wasNULL = true;
102 }
103 else
104 {
105 wasNULL = false;
106 theValue = *t;
107 originalPointer = t;
108 arraySize = 0;
109 }
110 }
111
112 public:
113 valueHolder(_In_ T* t) :
114 copyArray(NULL)
115 {
116 SetValue(t);
117 }
118
119 valueHolder(_In_ const valueHolder & t):
120 wasNULL(t.wasNULL), theValue(t.theValue), originalPointer(t.originalPointer), arraySize(t.arraySize)
121 {
122 if(t.copyArray!=NULL)
123 {
124 copyArray = new T[t.arraySize];
125 ASSERT_IS_TRUE(NULL != copyArray, _T("memory error"));
126 for(size_t i=0;i<t.arraySize;i++)
127 {
128 copyArray[i]=t.copyArray[i];
129 }
130 }
131 else
132 {
133 copyArray = NULL;
134 }
135 }
136 valueHolder():wasNULL(false),arraySize(0), copyArray(NULL), originalPointer(NULL)
137 {
138 }
139
140 virtual ~valueHolder()
141 {
142 if(copyArray!=NULL)
143 {
144 delete[] copyArray;
145 copyArray=NULL;
146 }
147 }
148
149 /*it could be just a simple pointer...*/
150 void operator=(_In_ T* t)
151 {
152 SetValue(t);
153 }
154
155 operator T*(void)
156 {
157 if(wasNULL)
158 {
159 return NULL;
160 }
161 else
162 {
163 if(arraySize==0)
164 {
165 return &theValue;
166 }
167 else
168 {
169 return copyArray;
170 }
171 }
172 }
173
174 /*or could be an array of user specififed length*/
175 void setArraySize(_In_ size_t size)
176 {
177 if(size==0)
178 {
179 ASSERT_FAIL("size cannot ever be 0 for an array");
180 }
181 else
182 {
183 if(copyArray!=NULL)
184 {
185 delete[] copyArray;
186 copyArray=NULL;
187 }
188
189 copyArray = new T[size];
190 ASSERT_IS_TRUE(copyArray != NULL, _T("catastrophic memory allocation error (out of memory?)"));
191 for(size_t i=0;i<size;i++)
192 {
193 copyArray[i]=originalPointer[i];
194 }
195 arraySize = size;
196 }
197 }
198 };
199
200 /*copy & paste from above, except the const modifier*/
201 template <typename T> class valueHolder <const T*>
202 {
203 private:
204 bool wasNULL;
205
206 T theValue;
207
208 const T* originalPointer;
209 T* copyArray;
210 size_t arraySize;
211
212 private:
213 void SetValue(_In_ const T* t)
214 {
215 if(t==NULL)
216 {
217 wasNULL = true;
218 }
219 else
220 {
221 wasNULL = false;
222 theValue = *t;
223 originalPointer = t;
224 arraySize = 0;
225 }
226 }
227
228 public:
229 valueHolder(_In_ const T* t) :
230 copyArray(NULL)
231 {
232 SetValue(t);
233 }
234
235 valueHolder(_In_ const valueHolder & t):
236 wasNULL(t.wasNULL), theValue(t.theValue), originalPointer(t.originalPointer), arraySize(t.arraySize)
237 {
238 if(t.copyArray!=NULL)
239 {
240 copyArray = new T[t.arraySize];
241 ASSERT_IS_TRUE(NULL != copyArray, _T("memory error"));
242 for(size_t i=0;i<t.arraySize;i++)
243 {
244 copyArray[i]=t.copyArray[i];
245 }
246 }
247 else
248 {
249 copyArray = NULL;
250 }
251 }
252 valueHolder():wasNULL(false),arraySize(0), copyArray(NULL), originalPointer(NULL)
253 {
254 }
255
256 virtual ~valueHolder()
257 {
258 if(copyArray!=NULL)
259 {
260 delete[]copyArray;
261 copyArray=NULL;
262 }
263 }
264
265 /*it could be just a simple pointer...*/
266 void operator=(_In_ const T* t)
267 {
268 SetValue(t);
269 }
270
271 operator T*(void)
272 {
273 if(wasNULL)
274 {
275 return NULL;
276 }
277 else
278 {
279 if(arraySize==0)
280 {
281 return &theValue;
282 }
283 else
284 {
285 return copyArray;
286 }
287 }
288 }
289
290 /*or could be an array of user specified length*/
291 void setArraySize(_In_ size_t size)
292 {
293 if(size==0)
294 {
295 ASSERT_FAIL("size cannot ever be 0 for an array");
296 }
297 else
298 {
299 if(copyArray!=NULL)
300 {
301 delete []copyArray;
302 copyArray=NULL;
303 }
304
305 copyArray=new T[size];
306 ASSERT_IS_TRUE(copyArray != NULL, _T("catastrophic memory allocation error (out of memory?)"));
307 for(size_t i=0;i<size;i++)
308 {
309 copyArray[i]=originalPointer[i];
310 }
311 arraySize = size;
312 }
313 }
314 };
315
316 /*this is a special case*/
317 template <> class valueHolder <char*>
318 {
319 private:
320 std::string theValue;
321 public:
322 valueHolder(_In_z_ char* t)
323 {
324 theValue = t;
325 }
326
327 void operator=(_In_z_ char* t)
328 {
329 theValue = t;
330 }
331
332 operator char*(void)
333 {
334 return (char*)(theValue.c_str());
335 }
336 };
337
338 /*this is a special case*/
339 template <> class valueHolder <wchar_t*>
340 {
341 private:
342 std::wstring theValue;
343 public:
344 valueHolder(_In_z_ wchar_t* t)
345 {
346 theValue = t;
347 }
348
349 void operator=(_In_z_ wchar_t* t)
350 {
351 theValue = t;
352 }
353
354 operator wchar_t*(void)
355 {
356 return (wchar_t*)theValue.c_str();
357 }
358 };
359
360
361
362 class stims_base
363 {
364 /*friends because registerCallXArg should not be available as public*/
365 template<typename resultType, class C> friend class call0Arg;
366 template<typename resultType, typename arg1Type, class C> friend class call1Arg;
367 template<typename resultType, typename arg1Type, typename arg2Type, class C> friend class call2Arg;
368 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, class C> friend class call3Arg;
369 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, class C> friend class call4Arg;
370 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, class C> friend class call5Arg;
371 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, class C> friend class call6Arg;
372 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, class C> friend class call7Arg;
373 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, class C> friend class call8Arg;
374 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, class C> friend class call9Arg;
375 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, class C> friend class call10Arg;
376 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, typename arg11Type, class C> friend class call11Arg;
377 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, typename arg11Type, typename arg12Type, class C> friend class call12Arg;
378 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, typename arg11Type, typename arg12Type, typename arg13Type, class C> friend class call13Arg;
379 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, typename arg11Type, typename arg12Type, typename arg13Type, typename arg14Type, class C> friend class call14Arg;
380 template<typename resultType, typename arg1Type, typename arg2Type, typename arg3Type, typename arg4Type, typename arg5Type, typename arg6Type, typename arg7Type, typename arg8Type, typename arg9Type, typename arg10Type, typename arg11Type, typename arg12Type, typename arg13Type, typename arg14Type, typename arg15Type, class C> friend class call15Arg;
381
382 private:
383 static std::vector<canPlay *> allPlayers;
384
385 static void registerCallXArg(canPlay* someStim)
386 {
387 allPlayers.push_back(someStim);
388 }
389
390 public:
391 virtual ~stims_base()
392 {
393 allPlayers.clear();
394 }
395
396 void static PlayTick(_In_ UINT32 tick, _In_ UINT32 order)
397 {
398 for(UINT32 i=0;i<allPlayers.size();i++)
399 {
400 allPlayers[i]->PlayTick(tick, order);
401 }
402 }
403 };
404
405 #include "timediscretemicromockcallmacros.h"
406
407 extern UINT32 theTick;
408 extern UINT32 totalTicksPlayed;
409 #define MAXTICK 1000000
410
411 class CTimeDiscreteMicroMockBase : public stims_base
412 {
413 private:
414 UINT32 m_currentTick;
415 void(*m_theTask)(void);
416 UINT32*maxOrder;
417 public:
418 /*the only constructor will accept a task given as function name*/
419 CTimeDiscreteMicroMockBase(_In_opt_ void(*p)(void)) :m_theTask(p)
420 {
421 maxOrder = (UINT32*)malloc(MAXTICK*sizeof(UINT32));
422 if (maxOrder == NULL)
423 {
424 MOCK_THROW(_T("out of memory"));
425 }
426 else
427 {
428 memset(maxOrder, 0xFF, MAXTICK*sizeof(UINT32));
429 }
430 }
431
432 virtual ~CTimeDiscreteMicroMockBase()
433 {
434 if (maxOrder != NULL)
435 {
436 free(maxOrder);
437 maxOrder = NULL;
438 }
439 }
440
441 void RunUntilTick(_In_ UINT32 nTick)
442 {
443 totalTicksPlayed += nTick;
444 if (nTick >= MAXTICK)
445 {
446 MOCK_THROW(_T("time detected bigger than MAXTICK"));
447 }
448 for (UINT32 i = 0; i <= nTick; i++)
449 {
450 m_currentTick = i;
451 theTick = m_currentTick;
452
453 if (maxOrder[i] != 0xFFFFFFFF)
454 {
455 for (UINT32 order = 0; order <= maxOrder[i]; order++)
456 {
457 stims_base::PlayTick(i, order);
458 }
459 }
460 m_theTask();
461 }
462 }
463
464 UINT32 getCurrentTick(void)
465 {
466 return m_currentTick;
467 }
468
469 UINT32 getAndIncOrder(_In_ UINT32 time)
470 {
471 if (time<MAXTICK)
472 {
473 if (maxOrder[time] == 0xFFFFFFFF)
474 {
475 maxOrder[time] = 0;
476 }
477 else
478 {
479 maxOrder[time] = maxOrder[time] + 1;
480 }
481 }
482 else
483 {
484 MOCK_THROW(_T("time detected bigger than MAXTICK"));
485 }
486
487 return maxOrder[time];
488 }
489 };
490
491 template<class T>
492 class CTimeDiscreteMicroMock: public T, public CTimeDiscreteMicroMockBase
493 {
494 public:
495 CTimeDiscreteMicroMock(void (*theTask)(void)):CTimeDiscreteMicroMockBase(theTask)
496 {
497 }
498 };
499
500
501 /*variable exports*/
502 /*function exports*/
503
504 #endif