1 /* AUTOGENERATED FILE. DO NOT EDIT. */
2 #include <string.h>
3 #include <stdlib.h>
4 #include <setjmp.h>
5 #include "cmock.h"
6 #include "Mockfwk_time.h"
7 
8 static const char* CMockString_ctx = "ctx";
9 static const char* CMockString_duration = "duration";
10 static const char* CMockString_end = "end";
11 static const char* CMockString_fmw_time_driver = "fmw_time_driver";
12 static const char* CMockString_fwk_time_current = "fwk_time_current";
13 static const char* CMockString_fwk_time_duration = "fwk_time_duration";
14 static const char* CMockString_fwk_time_duration_h = "fwk_time_duration_h";
15 static const char* CMockString_fwk_time_duration_m = "fwk_time_duration_m";
16 static const char* CMockString_fwk_time_duration_ms = "fwk_time_duration_ms";
17 static const char* CMockString_fwk_time_duration_s = "fwk_time_duration_s";
18 static const char* CMockString_fwk_time_duration_us = "fwk_time_duration_us";
19 static const char* CMockString_fwk_time_stamp_duration = "fwk_time_stamp_duration";
20 static const char* CMockString_start = "start";
21 static const char* CMockString_timestamp = "timestamp";
22 
23 typedef struct _CMOCK_fwk_time_current_CALL_INSTANCE
24 {
25   UNITY_LINE_TYPE LineNumber;
26   char ExpectAnyArgsBool;
27   fwk_timestamp_t ReturnVal;
28 
29 } CMOCK_fwk_time_current_CALL_INSTANCE;
30 
31 typedef struct _CMOCK_fwk_time_stamp_duration_CALL_INSTANCE
32 {
33   UNITY_LINE_TYPE LineNumber;
34   char ExpectAnyArgsBool;
35   fwk_duration_ns_t ReturnVal;
36   fwk_timestamp_t Expected_timestamp;
37   char IgnoreArg_timestamp;
38 
39 } CMOCK_fwk_time_stamp_duration_CALL_INSTANCE;
40 
41 typedef struct _CMOCK_fwk_time_duration_CALL_INSTANCE
42 {
43   UNITY_LINE_TYPE LineNumber;
44   char ExpectAnyArgsBool;
45   fwk_duration_ns_t ReturnVal;
46   fwk_timestamp_t Expected_start;
47   fwk_timestamp_t Expected_end;
48   char IgnoreArg_start;
49   char IgnoreArg_end;
50 
51 } CMOCK_fwk_time_duration_CALL_INSTANCE;
52 
53 typedef struct _CMOCK_fwk_time_duration_us_CALL_INSTANCE
54 {
55   UNITY_LINE_TYPE LineNumber;
56   char ExpectAnyArgsBool;
57   fwk_duration_us_t ReturnVal;
58   fwk_duration_ns_t Expected_duration;
59   char IgnoreArg_duration;
60 
61 } CMOCK_fwk_time_duration_us_CALL_INSTANCE;
62 
63 typedef struct _CMOCK_fwk_time_duration_ms_CALL_INSTANCE
64 {
65   UNITY_LINE_TYPE LineNumber;
66   char ExpectAnyArgsBool;
67   fwk_duration_ms_t ReturnVal;
68   fwk_duration_ns_t Expected_duration;
69   char IgnoreArg_duration;
70 
71 } CMOCK_fwk_time_duration_ms_CALL_INSTANCE;
72 
73 typedef struct _CMOCK_fwk_time_duration_s_CALL_INSTANCE
74 {
75   UNITY_LINE_TYPE LineNumber;
76   char ExpectAnyArgsBool;
77   fwk_duration_s_t ReturnVal;
78   fwk_duration_ns_t Expected_duration;
79   char IgnoreArg_duration;
80 
81 } CMOCK_fwk_time_duration_s_CALL_INSTANCE;
82 
83 typedef struct _CMOCK_fwk_time_duration_m_CALL_INSTANCE
84 {
85   UNITY_LINE_TYPE LineNumber;
86   char ExpectAnyArgsBool;
87   fwk_duration_m_t ReturnVal;
88   fwk_duration_ns_t Expected_duration;
89   char IgnoreArg_duration;
90 
91 } CMOCK_fwk_time_duration_m_CALL_INSTANCE;
92 
93 typedef struct _CMOCK_fwk_time_duration_h_CALL_INSTANCE
94 {
95   UNITY_LINE_TYPE LineNumber;
96   char ExpectAnyArgsBool;
97   fwk_duration_h_t ReturnVal;
98   fwk_duration_ns_t Expected_duration;
99   char IgnoreArg_duration;
100 
101 } CMOCK_fwk_time_duration_h_CALL_INSTANCE;
102 
103 typedef struct _CMOCK_fmw_time_driver_CALL_INSTANCE
104 {
105   UNITY_LINE_TYPE LineNumber;
106   char ExpectAnyArgsBool;
107   struct fwk_time_driver ReturnVal;
108   const void** Expected_ctx;
109   int Expected_ctx_Depth;
110   char ReturnThruPtr_ctx_Used;
111   const void** ReturnThruPtr_ctx_Val;
112   size_t ReturnThruPtr_ctx_Size;
113   char IgnoreArg_ctx;
114 
115 } CMOCK_fmw_time_driver_CALL_INSTANCE;
116 
117 static struct Mockfwk_timeInstance
118 {
119   char fwk_time_current_IgnoreBool;
120   fwk_timestamp_t fwk_time_current_FinalReturn;
121   char fwk_time_current_CallbackBool;
122   CMOCK_fwk_time_current_CALLBACK fwk_time_current_CallbackFunctionPointer;
123   int fwk_time_current_CallbackCalls;
124   CMOCK_MEM_INDEX_TYPE fwk_time_current_CallInstance;
125   char fwk_time_stamp_duration_IgnoreBool;
126   fwk_duration_ns_t fwk_time_stamp_duration_FinalReturn;
127   char fwk_time_stamp_duration_CallbackBool;
128   CMOCK_fwk_time_stamp_duration_CALLBACK fwk_time_stamp_duration_CallbackFunctionPointer;
129   int fwk_time_stamp_duration_CallbackCalls;
130   CMOCK_MEM_INDEX_TYPE fwk_time_stamp_duration_CallInstance;
131   char fwk_time_duration_IgnoreBool;
132   fwk_duration_ns_t fwk_time_duration_FinalReturn;
133   char fwk_time_duration_CallbackBool;
134   CMOCK_fwk_time_duration_CALLBACK fwk_time_duration_CallbackFunctionPointer;
135   int fwk_time_duration_CallbackCalls;
136   CMOCK_MEM_INDEX_TYPE fwk_time_duration_CallInstance;
137   char fwk_time_duration_us_IgnoreBool;
138   fwk_duration_us_t fwk_time_duration_us_FinalReturn;
139   char fwk_time_duration_us_CallbackBool;
140   CMOCK_fwk_time_duration_us_CALLBACK fwk_time_duration_us_CallbackFunctionPointer;
141   int fwk_time_duration_us_CallbackCalls;
142   CMOCK_MEM_INDEX_TYPE fwk_time_duration_us_CallInstance;
143   char fwk_time_duration_ms_IgnoreBool;
144   fwk_duration_ms_t fwk_time_duration_ms_FinalReturn;
145   char fwk_time_duration_ms_CallbackBool;
146   CMOCK_fwk_time_duration_ms_CALLBACK fwk_time_duration_ms_CallbackFunctionPointer;
147   int fwk_time_duration_ms_CallbackCalls;
148   CMOCK_MEM_INDEX_TYPE fwk_time_duration_ms_CallInstance;
149   char fwk_time_duration_s_IgnoreBool;
150   fwk_duration_s_t fwk_time_duration_s_FinalReturn;
151   char fwk_time_duration_s_CallbackBool;
152   CMOCK_fwk_time_duration_s_CALLBACK fwk_time_duration_s_CallbackFunctionPointer;
153   int fwk_time_duration_s_CallbackCalls;
154   CMOCK_MEM_INDEX_TYPE fwk_time_duration_s_CallInstance;
155   char fwk_time_duration_m_IgnoreBool;
156   fwk_duration_m_t fwk_time_duration_m_FinalReturn;
157   char fwk_time_duration_m_CallbackBool;
158   CMOCK_fwk_time_duration_m_CALLBACK fwk_time_duration_m_CallbackFunctionPointer;
159   int fwk_time_duration_m_CallbackCalls;
160   CMOCK_MEM_INDEX_TYPE fwk_time_duration_m_CallInstance;
161   char fwk_time_duration_h_IgnoreBool;
162   fwk_duration_h_t fwk_time_duration_h_FinalReturn;
163   char fwk_time_duration_h_CallbackBool;
164   CMOCK_fwk_time_duration_h_CALLBACK fwk_time_duration_h_CallbackFunctionPointer;
165   int fwk_time_duration_h_CallbackCalls;
166   CMOCK_MEM_INDEX_TYPE fwk_time_duration_h_CallInstance;
167   char fmw_time_driver_IgnoreBool;
168   struct fwk_time_driver fmw_time_driver_FinalReturn;
169   char fmw_time_driver_CallbackBool;
170   CMOCK_fmw_time_driver_CALLBACK fmw_time_driver_CallbackFunctionPointer;
171   int fmw_time_driver_CallbackCalls;
172   CMOCK_MEM_INDEX_TYPE fmw_time_driver_CallInstance;
173 } Mock;
174 
175 extern jmp_buf AbortFrame;
176 
Mockfwk_time_Verify(void)177 void Mockfwk_time_Verify(void)
178 {
179   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
180   CMOCK_MEM_INDEX_TYPE call_instance;
181   call_instance = Mock.fwk_time_current_CallInstance;
182   if (Mock.fwk_time_current_IgnoreBool)
183     call_instance = CMOCK_GUTS_NONE;
184   if (CMOCK_GUTS_NONE != call_instance)
185   {
186     UNITY_SET_DETAIL(CMockString_fwk_time_current);
187     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
188   }
189   if (Mock.fwk_time_current_CallbackFunctionPointer != NULL)
190   {
191     call_instance = CMOCK_GUTS_NONE;
192     (void)call_instance;
193   }
194   call_instance = Mock.fwk_time_stamp_duration_CallInstance;
195   if (Mock.fwk_time_stamp_duration_IgnoreBool)
196     call_instance = CMOCK_GUTS_NONE;
197   if (CMOCK_GUTS_NONE != call_instance)
198   {
199     UNITY_SET_DETAIL(CMockString_fwk_time_stamp_duration);
200     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
201   }
202   if (Mock.fwk_time_stamp_duration_CallbackFunctionPointer != NULL)
203   {
204     call_instance = CMOCK_GUTS_NONE;
205     (void)call_instance;
206   }
207   call_instance = Mock.fwk_time_duration_CallInstance;
208   if (Mock.fwk_time_duration_IgnoreBool)
209     call_instance = CMOCK_GUTS_NONE;
210   if (CMOCK_GUTS_NONE != call_instance)
211   {
212     UNITY_SET_DETAIL(CMockString_fwk_time_duration);
213     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
214   }
215   if (Mock.fwk_time_duration_CallbackFunctionPointer != NULL)
216   {
217     call_instance = CMOCK_GUTS_NONE;
218     (void)call_instance;
219   }
220   call_instance = Mock.fwk_time_duration_us_CallInstance;
221   if (Mock.fwk_time_duration_us_IgnoreBool)
222     call_instance = CMOCK_GUTS_NONE;
223   if (CMOCK_GUTS_NONE != call_instance)
224   {
225     UNITY_SET_DETAIL(CMockString_fwk_time_duration_us);
226     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
227   }
228   if (Mock.fwk_time_duration_us_CallbackFunctionPointer != NULL)
229   {
230     call_instance = CMOCK_GUTS_NONE;
231     (void)call_instance;
232   }
233   call_instance = Mock.fwk_time_duration_ms_CallInstance;
234   if (Mock.fwk_time_duration_ms_IgnoreBool)
235     call_instance = CMOCK_GUTS_NONE;
236   if (CMOCK_GUTS_NONE != call_instance)
237   {
238     UNITY_SET_DETAIL(CMockString_fwk_time_duration_ms);
239     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
240   }
241   if (Mock.fwk_time_duration_ms_CallbackFunctionPointer != NULL)
242   {
243     call_instance = CMOCK_GUTS_NONE;
244     (void)call_instance;
245   }
246   call_instance = Mock.fwk_time_duration_s_CallInstance;
247   if (Mock.fwk_time_duration_s_IgnoreBool)
248     call_instance = CMOCK_GUTS_NONE;
249   if (CMOCK_GUTS_NONE != call_instance)
250   {
251     UNITY_SET_DETAIL(CMockString_fwk_time_duration_s);
252     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
253   }
254   if (Mock.fwk_time_duration_s_CallbackFunctionPointer != NULL)
255   {
256     call_instance = CMOCK_GUTS_NONE;
257     (void)call_instance;
258   }
259   call_instance = Mock.fwk_time_duration_m_CallInstance;
260   if (Mock.fwk_time_duration_m_IgnoreBool)
261     call_instance = CMOCK_GUTS_NONE;
262   if (CMOCK_GUTS_NONE != call_instance)
263   {
264     UNITY_SET_DETAIL(CMockString_fwk_time_duration_m);
265     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
266   }
267   if (Mock.fwk_time_duration_m_CallbackFunctionPointer != NULL)
268   {
269     call_instance = CMOCK_GUTS_NONE;
270     (void)call_instance;
271   }
272   call_instance = Mock.fwk_time_duration_h_CallInstance;
273   if (Mock.fwk_time_duration_h_IgnoreBool)
274     call_instance = CMOCK_GUTS_NONE;
275   if (CMOCK_GUTS_NONE != call_instance)
276   {
277     UNITY_SET_DETAIL(CMockString_fwk_time_duration_h);
278     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
279   }
280   if (Mock.fwk_time_duration_h_CallbackFunctionPointer != NULL)
281   {
282     call_instance = CMOCK_GUTS_NONE;
283     (void)call_instance;
284   }
285   call_instance = Mock.fmw_time_driver_CallInstance;
286   if (Mock.fmw_time_driver_IgnoreBool)
287     call_instance = CMOCK_GUTS_NONE;
288   if (CMOCK_GUTS_NONE != call_instance)
289   {
290     UNITY_SET_DETAIL(CMockString_fmw_time_driver);
291     UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
292   }
293   if (Mock.fmw_time_driver_CallbackFunctionPointer != NULL)
294   {
295     call_instance = CMOCK_GUTS_NONE;
296     (void)call_instance;
297   }
298 }
299 
Mockfwk_time_Init(void)300 void Mockfwk_time_Init(void)
301 {
302   Mockfwk_time_Destroy();
303 }
304 
Mockfwk_time_Destroy(void)305 void Mockfwk_time_Destroy(void)
306 {
307   CMock_Guts_MemFreeAll();
308   memset(&Mock, 0, sizeof(Mock));
309 }
310 
fwk_time_current(void)311 fwk_timestamp_t fwk_time_current(void)
312 {
313   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
314   CMOCK_fwk_time_current_CALL_INSTANCE* cmock_call_instance;
315   UNITY_SET_DETAIL(CMockString_fwk_time_current);
316   cmock_call_instance = (CMOCK_fwk_time_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_current_CallInstance);
317   Mock.fwk_time_current_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_current_CallInstance);
318   if (Mock.fwk_time_current_IgnoreBool)
319   {
320     UNITY_CLR_DETAILS();
321     if (cmock_call_instance == NULL)
322       return Mock.fwk_time_current_FinalReturn;
323     memcpy((void*)(&Mock.fwk_time_current_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
324          sizeof(fwk_timestamp_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_timestamp_t) ? 1 : -1])); /* add fwk_timestamp_t to :treat_as_array if this causes an error */
325     return cmock_call_instance->ReturnVal;
326   }
327   if (!Mock.fwk_time_current_CallbackBool &&
328       Mock.fwk_time_current_CallbackFunctionPointer != NULL)
329   {
330     fwk_timestamp_t cmock_cb_ret = Mock.fwk_time_current_CallbackFunctionPointer(Mock.fwk_time_current_CallbackCalls++);
331     UNITY_CLR_DETAILS();
332     return cmock_cb_ret;
333   }
334   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
335   cmock_line = cmock_call_instance->LineNumber;
336   if (Mock.fwk_time_current_CallbackFunctionPointer != NULL)
337   {
338     cmock_call_instance->ReturnVal = Mock.fwk_time_current_CallbackFunctionPointer(Mock.fwk_time_current_CallbackCalls++);
339   }
340   UNITY_CLR_DETAILS();
341   return cmock_call_instance->ReturnVal;
342 }
343 
fwk_time_current_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_timestamp_t cmock_to_return)344 void fwk_time_current_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_timestamp_t cmock_to_return)
345 {
346   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_current_CALL_INSTANCE));
347   CMOCK_fwk_time_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
348   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
349   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
350   Mock.fwk_time_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_current_CallInstance, cmock_guts_index);
351   Mock.fwk_time_current_IgnoreBool = (char)0;
352   cmock_call_instance->LineNumber = cmock_line;
353   cmock_call_instance->ExpectAnyArgsBool = (char)0;
354   cmock_call_instance->ReturnVal = cmock_to_return;
355   Mock.fwk_time_current_IgnoreBool = (char)1;
356 }
357 
fwk_time_current_CMockStopIgnore(void)358 void fwk_time_current_CMockStopIgnore(void)
359 {
360   if(Mock.fwk_time_current_IgnoreBool)
361     Mock.fwk_time_current_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_current_CallInstance);
362   Mock.fwk_time_current_IgnoreBool = (char)0;
363 }
364 
fwk_time_current_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_timestamp_t cmock_to_return)365 void fwk_time_current_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_timestamp_t cmock_to_return)
366 {
367   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_current_CALL_INSTANCE));
368   CMOCK_fwk_time_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
369   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
370   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
371   Mock.fwk_time_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_current_CallInstance, cmock_guts_index);
372   Mock.fwk_time_current_IgnoreBool = (char)0;
373   cmock_call_instance->LineNumber = cmock_line;
374   cmock_call_instance->ExpectAnyArgsBool = (char)0;
375   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
376          sizeof(fwk_timestamp_t[sizeof(cmock_to_return) == sizeof(fwk_timestamp_t) ? 1 : -1])); /* add fwk_timestamp_t to :treat_as_array if this causes an error */
377 }
378 
fwk_time_current_AddCallback(CMOCK_fwk_time_current_CALLBACK Callback)379 void fwk_time_current_AddCallback(CMOCK_fwk_time_current_CALLBACK Callback)
380 {
381   Mock.fwk_time_current_IgnoreBool = (char)0;
382   Mock.fwk_time_current_CallbackBool = (char)1;
383   Mock.fwk_time_current_CallbackFunctionPointer = Callback;
384 }
385 
fwk_time_current_Stub(CMOCK_fwk_time_current_CALLBACK Callback)386 void fwk_time_current_Stub(CMOCK_fwk_time_current_CALLBACK Callback)
387 {
388   Mock.fwk_time_current_IgnoreBool = (char)0;
389   Mock.fwk_time_current_CallbackBool = (char)0;
390   Mock.fwk_time_current_CallbackFunctionPointer = Callback;
391 }
392 
fwk_time_stamp_duration(fwk_timestamp_t timestamp)393 fwk_duration_ns_t fwk_time_stamp_duration(fwk_timestamp_t timestamp)
394 {
395   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
396   CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance;
397   UNITY_SET_DETAIL(CMockString_fwk_time_stamp_duration);
398   cmock_call_instance = (CMOCK_fwk_time_stamp_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_stamp_duration_CallInstance);
399   Mock.fwk_time_stamp_duration_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_stamp_duration_CallInstance);
400   if (Mock.fwk_time_stamp_duration_IgnoreBool)
401   {
402     UNITY_CLR_DETAILS();
403     if (cmock_call_instance == NULL)
404       return Mock.fwk_time_stamp_duration_FinalReturn;
405     memcpy((void*)(&Mock.fwk_time_stamp_duration_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
406          sizeof(fwk_duration_ns_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
407     return cmock_call_instance->ReturnVal;
408   }
409   if (!Mock.fwk_time_stamp_duration_CallbackBool &&
410       Mock.fwk_time_stamp_duration_CallbackFunctionPointer != NULL)
411   {
412     fwk_duration_ns_t cmock_cb_ret = Mock.fwk_time_stamp_duration_CallbackFunctionPointer(timestamp, Mock.fwk_time_stamp_duration_CallbackCalls++);
413     UNITY_CLR_DETAILS();
414     return cmock_cb_ret;
415   }
416   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
417   cmock_line = cmock_call_instance->LineNumber;
418   if (!cmock_call_instance->ExpectAnyArgsBool)
419   {
420   if (!cmock_call_instance->IgnoreArg_timestamp)
421   {
422     UNITY_SET_DETAILS(CMockString_fwk_time_stamp_duration,CMockString_timestamp);
423     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_timestamp), (void*)(&timestamp), sizeof(fwk_timestamp_t), cmock_line, CMockStringMismatch);
424   }
425   }
426   if (Mock.fwk_time_stamp_duration_CallbackFunctionPointer != NULL)
427   {
428     cmock_call_instance->ReturnVal = Mock.fwk_time_stamp_duration_CallbackFunctionPointer(timestamp, Mock.fwk_time_stamp_duration_CallbackCalls++);
429   }
430   UNITY_CLR_DETAILS();
431   return cmock_call_instance->ReturnVal;
432 }
433 
434 void CMockExpectParameters_fwk_time_stamp_duration(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance, fwk_timestamp_t timestamp);
CMockExpectParameters_fwk_time_stamp_duration(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE * cmock_call_instance,fwk_timestamp_t timestamp)435 void CMockExpectParameters_fwk_time_stamp_duration(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance, fwk_timestamp_t timestamp)
436 {
437   memcpy((void*)(&cmock_call_instance->Expected_timestamp), (void*)(&timestamp),
438          sizeof(fwk_timestamp_t[sizeof(timestamp) == sizeof(fwk_timestamp_t) ? 1 : -1])); /* add fwk_timestamp_t to :treat_as_array if this causes an error */
439   cmock_call_instance->IgnoreArg_timestamp = 0;
440 }
441 
fwk_time_stamp_duration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t cmock_to_return)442 void fwk_time_stamp_duration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t cmock_to_return)
443 {
444   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE));
445   CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_stamp_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
446   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
447   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
448   Mock.fwk_time_stamp_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_stamp_duration_CallInstance, cmock_guts_index);
449   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
450   cmock_call_instance->LineNumber = cmock_line;
451   cmock_call_instance->ExpectAnyArgsBool = (char)0;
452   cmock_call_instance->ReturnVal = cmock_to_return;
453   Mock.fwk_time_stamp_duration_IgnoreBool = (char)1;
454 }
455 
fwk_time_stamp_duration_CMockStopIgnore(void)456 void fwk_time_stamp_duration_CMockStopIgnore(void)
457 {
458   if(Mock.fwk_time_stamp_duration_IgnoreBool)
459     Mock.fwk_time_stamp_duration_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_stamp_duration_CallInstance);
460   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
461 }
462 
fwk_time_stamp_duration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t cmock_to_return)463 void fwk_time_stamp_duration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t cmock_to_return)
464 {
465   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE));
466   CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_stamp_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
467   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
468   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
469   Mock.fwk_time_stamp_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_stamp_duration_CallInstance, cmock_guts_index);
470   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
471   cmock_call_instance->LineNumber = cmock_line;
472   cmock_call_instance->ExpectAnyArgsBool = (char)0;
473   cmock_call_instance->ReturnVal = cmock_to_return;
474   cmock_call_instance->ExpectAnyArgsBool = (char)1;
475 }
476 
fwk_time_stamp_duration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_timestamp_t timestamp,fwk_duration_ns_t cmock_to_return)477 void fwk_time_stamp_duration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_timestamp_t timestamp, fwk_duration_ns_t cmock_to_return)
478 {
479   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_stamp_duration_CALL_INSTANCE));
480   CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_stamp_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
481   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
482   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
483   Mock.fwk_time_stamp_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_stamp_duration_CallInstance, cmock_guts_index);
484   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
485   cmock_call_instance->LineNumber = cmock_line;
486   cmock_call_instance->ExpectAnyArgsBool = (char)0;
487   CMockExpectParameters_fwk_time_stamp_duration(cmock_call_instance, timestamp);
488   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
489          sizeof(fwk_duration_ns_t[sizeof(cmock_to_return) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
490 }
491 
fwk_time_stamp_duration_AddCallback(CMOCK_fwk_time_stamp_duration_CALLBACK Callback)492 void fwk_time_stamp_duration_AddCallback(CMOCK_fwk_time_stamp_duration_CALLBACK Callback)
493 {
494   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
495   Mock.fwk_time_stamp_duration_CallbackBool = (char)1;
496   Mock.fwk_time_stamp_duration_CallbackFunctionPointer = Callback;
497 }
498 
fwk_time_stamp_duration_Stub(CMOCK_fwk_time_stamp_duration_CALLBACK Callback)499 void fwk_time_stamp_duration_Stub(CMOCK_fwk_time_stamp_duration_CALLBACK Callback)
500 {
501   Mock.fwk_time_stamp_duration_IgnoreBool = (char)0;
502   Mock.fwk_time_stamp_duration_CallbackBool = (char)0;
503   Mock.fwk_time_stamp_duration_CallbackFunctionPointer = Callback;
504 }
505 
fwk_time_stamp_duration_CMockIgnoreArg_timestamp(UNITY_LINE_TYPE cmock_line)506 void fwk_time_stamp_duration_CMockIgnoreArg_timestamp(UNITY_LINE_TYPE cmock_line)
507 {
508   CMOCK_fwk_time_stamp_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_stamp_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_stamp_duration_CallInstance));
509   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
510   cmock_call_instance->IgnoreArg_timestamp = 1;
511 }
512 
fwk_time_duration(fwk_timestamp_t start,fwk_timestamp_t end)513 fwk_duration_ns_t fwk_time_duration(fwk_timestamp_t start, fwk_timestamp_t end)
514 {
515   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
516   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance;
517   UNITY_SET_DETAIL(CMockString_fwk_time_duration);
518   cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_CallInstance);
519   Mock.fwk_time_duration_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_CallInstance);
520   if (Mock.fwk_time_duration_IgnoreBool)
521   {
522     UNITY_CLR_DETAILS();
523     if (cmock_call_instance == NULL)
524       return Mock.fwk_time_duration_FinalReturn;
525     memcpy((void*)(&Mock.fwk_time_duration_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
526          sizeof(fwk_duration_ns_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
527     return cmock_call_instance->ReturnVal;
528   }
529   if (!Mock.fwk_time_duration_CallbackBool &&
530       Mock.fwk_time_duration_CallbackFunctionPointer != NULL)
531   {
532     fwk_duration_ns_t cmock_cb_ret = Mock.fwk_time_duration_CallbackFunctionPointer(start, end, Mock.fwk_time_duration_CallbackCalls++);
533     UNITY_CLR_DETAILS();
534     return cmock_cb_ret;
535   }
536   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
537   cmock_line = cmock_call_instance->LineNumber;
538   if (!cmock_call_instance->ExpectAnyArgsBool)
539   {
540   if (!cmock_call_instance->IgnoreArg_start)
541   {
542     UNITY_SET_DETAILS(CMockString_fwk_time_duration,CMockString_start);
543     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_start), (void*)(&start), sizeof(fwk_timestamp_t), cmock_line, CMockStringMismatch);
544   }
545   if (!cmock_call_instance->IgnoreArg_end)
546   {
547     UNITY_SET_DETAILS(CMockString_fwk_time_duration,CMockString_end);
548     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_end), (void*)(&end), sizeof(fwk_timestamp_t), cmock_line, CMockStringMismatch);
549   }
550   }
551   if (Mock.fwk_time_duration_CallbackFunctionPointer != NULL)
552   {
553     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_CallbackFunctionPointer(start, end, Mock.fwk_time_duration_CallbackCalls++);
554   }
555   UNITY_CLR_DETAILS();
556   return cmock_call_instance->ReturnVal;
557 }
558 
559 void CMockExpectParameters_fwk_time_duration(CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance, fwk_timestamp_t start, fwk_timestamp_t end);
CMockExpectParameters_fwk_time_duration(CMOCK_fwk_time_duration_CALL_INSTANCE * cmock_call_instance,fwk_timestamp_t start,fwk_timestamp_t end)560 void CMockExpectParameters_fwk_time_duration(CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance, fwk_timestamp_t start, fwk_timestamp_t end)
561 {
562   memcpy((void*)(&cmock_call_instance->Expected_start), (void*)(&start),
563          sizeof(fwk_timestamp_t[sizeof(start) == sizeof(fwk_timestamp_t) ? 1 : -1])); /* add fwk_timestamp_t to :treat_as_array if this causes an error */
564   cmock_call_instance->IgnoreArg_start = 0;
565   memcpy((void*)(&cmock_call_instance->Expected_end), (void*)(&end),
566          sizeof(fwk_timestamp_t[sizeof(end) == sizeof(fwk_timestamp_t) ? 1 : -1])); /* add fwk_timestamp_t to :treat_as_array if this causes an error */
567   cmock_call_instance->IgnoreArg_end = 0;
568 }
569 
fwk_time_duration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t cmock_to_return)570 void fwk_time_duration_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t cmock_to_return)
571 {
572   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_CALL_INSTANCE));
573   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
574   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
575   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
576   Mock.fwk_time_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_CallInstance, cmock_guts_index);
577   Mock.fwk_time_duration_IgnoreBool = (char)0;
578   cmock_call_instance->LineNumber = cmock_line;
579   cmock_call_instance->ExpectAnyArgsBool = (char)0;
580   cmock_call_instance->ReturnVal = cmock_to_return;
581   Mock.fwk_time_duration_IgnoreBool = (char)1;
582 }
583 
fwk_time_duration_CMockStopIgnore(void)584 void fwk_time_duration_CMockStopIgnore(void)
585 {
586   if(Mock.fwk_time_duration_IgnoreBool)
587     Mock.fwk_time_duration_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_CallInstance);
588   Mock.fwk_time_duration_IgnoreBool = (char)0;
589 }
590 
fwk_time_duration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t cmock_to_return)591 void fwk_time_duration_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t cmock_to_return)
592 {
593   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_CALL_INSTANCE));
594   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
595   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
596   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
597   Mock.fwk_time_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_CallInstance, cmock_guts_index);
598   Mock.fwk_time_duration_IgnoreBool = (char)0;
599   cmock_call_instance->LineNumber = cmock_line;
600   cmock_call_instance->ExpectAnyArgsBool = (char)0;
601   cmock_call_instance->ReturnVal = cmock_to_return;
602   cmock_call_instance->ExpectAnyArgsBool = (char)1;
603 }
604 
fwk_time_duration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_timestamp_t start,fwk_timestamp_t end,fwk_duration_ns_t cmock_to_return)605 void fwk_time_duration_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_timestamp_t start, fwk_timestamp_t end, fwk_duration_ns_t cmock_to_return)
606 {
607   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_CALL_INSTANCE));
608   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
609   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
610   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
611   Mock.fwk_time_duration_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_CallInstance, cmock_guts_index);
612   Mock.fwk_time_duration_IgnoreBool = (char)0;
613   cmock_call_instance->LineNumber = cmock_line;
614   cmock_call_instance->ExpectAnyArgsBool = (char)0;
615   CMockExpectParameters_fwk_time_duration(cmock_call_instance, start, end);
616   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
617          sizeof(fwk_duration_ns_t[sizeof(cmock_to_return) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
618 }
619 
fwk_time_duration_AddCallback(CMOCK_fwk_time_duration_CALLBACK Callback)620 void fwk_time_duration_AddCallback(CMOCK_fwk_time_duration_CALLBACK Callback)
621 {
622   Mock.fwk_time_duration_IgnoreBool = (char)0;
623   Mock.fwk_time_duration_CallbackBool = (char)1;
624   Mock.fwk_time_duration_CallbackFunctionPointer = Callback;
625 }
626 
fwk_time_duration_Stub(CMOCK_fwk_time_duration_CALLBACK Callback)627 void fwk_time_duration_Stub(CMOCK_fwk_time_duration_CALLBACK Callback)
628 {
629   Mock.fwk_time_duration_IgnoreBool = (char)0;
630   Mock.fwk_time_duration_CallbackBool = (char)0;
631   Mock.fwk_time_duration_CallbackFunctionPointer = Callback;
632 }
633 
fwk_time_duration_CMockIgnoreArg_start(UNITY_LINE_TYPE cmock_line)634 void fwk_time_duration_CMockIgnoreArg_start(UNITY_LINE_TYPE cmock_line)
635 {
636   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_CallInstance));
637   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
638   cmock_call_instance->IgnoreArg_start = 1;
639 }
640 
fwk_time_duration_CMockIgnoreArg_end(UNITY_LINE_TYPE cmock_line)641 void fwk_time_duration_CMockIgnoreArg_end(UNITY_LINE_TYPE cmock_line)
642 {
643   CMOCK_fwk_time_duration_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_CallInstance));
644   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
645   cmock_call_instance->IgnoreArg_end = 1;
646 }
647 
fwk_time_duration_us(fwk_duration_ns_t duration)648 fwk_duration_us_t fwk_time_duration_us(fwk_duration_ns_t duration)
649 {
650   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
651   CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance;
652   UNITY_SET_DETAIL(CMockString_fwk_time_duration_us);
653   cmock_call_instance = (CMOCK_fwk_time_duration_us_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_us_CallInstance);
654   Mock.fwk_time_duration_us_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_us_CallInstance);
655   if (Mock.fwk_time_duration_us_IgnoreBool)
656   {
657     UNITY_CLR_DETAILS();
658     if (cmock_call_instance == NULL)
659       return Mock.fwk_time_duration_us_FinalReturn;
660     memcpy((void*)(&Mock.fwk_time_duration_us_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
661          sizeof(fwk_duration_us_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_us_t) ? 1 : -1])); /* add fwk_duration_us_t to :treat_as_array if this causes an error */
662     return cmock_call_instance->ReturnVal;
663   }
664   if (!Mock.fwk_time_duration_us_CallbackBool &&
665       Mock.fwk_time_duration_us_CallbackFunctionPointer != NULL)
666   {
667     fwk_duration_us_t cmock_cb_ret = Mock.fwk_time_duration_us_CallbackFunctionPointer(duration, Mock.fwk_time_duration_us_CallbackCalls++);
668     UNITY_CLR_DETAILS();
669     return cmock_cb_ret;
670   }
671   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
672   cmock_line = cmock_call_instance->LineNumber;
673   if (!cmock_call_instance->ExpectAnyArgsBool)
674   {
675   if (!cmock_call_instance->IgnoreArg_duration)
676   {
677     UNITY_SET_DETAILS(CMockString_fwk_time_duration_us,CMockString_duration);
678     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration), sizeof(fwk_duration_ns_t), cmock_line, CMockStringMismatch);
679   }
680   }
681   if (Mock.fwk_time_duration_us_CallbackFunctionPointer != NULL)
682   {
683     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_us_CallbackFunctionPointer(duration, Mock.fwk_time_duration_us_CallbackCalls++);
684   }
685   UNITY_CLR_DETAILS();
686   return cmock_call_instance->ReturnVal;
687 }
688 
689 void CMockExpectParameters_fwk_time_duration_us(CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration);
CMockExpectParameters_fwk_time_duration_us(CMOCK_fwk_time_duration_us_CALL_INSTANCE * cmock_call_instance,fwk_duration_ns_t duration)690 void CMockExpectParameters_fwk_time_duration_us(CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration)
691 {
692   memcpy((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration),
693          sizeof(fwk_duration_ns_t[sizeof(duration) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
694   cmock_call_instance->IgnoreArg_duration = 0;
695 }
696 
fwk_time_duration_us_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_us_t cmock_to_return)697 void fwk_time_duration_us_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_us_t cmock_to_return)
698 {
699   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_us_CALL_INSTANCE));
700   CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_us_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
701   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
702   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
703   Mock.fwk_time_duration_us_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_us_CallInstance, cmock_guts_index);
704   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
705   cmock_call_instance->LineNumber = cmock_line;
706   cmock_call_instance->ExpectAnyArgsBool = (char)0;
707   cmock_call_instance->ReturnVal = cmock_to_return;
708   Mock.fwk_time_duration_us_IgnoreBool = (char)1;
709 }
710 
fwk_time_duration_us_CMockStopIgnore(void)711 void fwk_time_duration_us_CMockStopIgnore(void)
712 {
713   if(Mock.fwk_time_duration_us_IgnoreBool)
714     Mock.fwk_time_duration_us_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_us_CallInstance);
715   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
716 }
717 
fwk_time_duration_us_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_us_t cmock_to_return)718 void fwk_time_duration_us_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_us_t cmock_to_return)
719 {
720   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_us_CALL_INSTANCE));
721   CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_us_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
722   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
723   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
724   Mock.fwk_time_duration_us_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_us_CallInstance, cmock_guts_index);
725   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
726   cmock_call_instance->LineNumber = cmock_line;
727   cmock_call_instance->ExpectAnyArgsBool = (char)0;
728   cmock_call_instance->ReturnVal = cmock_to_return;
729   cmock_call_instance->ExpectAnyArgsBool = (char)1;
730 }
731 
fwk_time_duration_us_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t duration,fwk_duration_us_t cmock_to_return)732 void fwk_time_duration_us_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t duration, fwk_duration_us_t cmock_to_return)
733 {
734   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_us_CALL_INSTANCE));
735   CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_us_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
736   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
737   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
738   Mock.fwk_time_duration_us_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_us_CallInstance, cmock_guts_index);
739   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
740   cmock_call_instance->LineNumber = cmock_line;
741   cmock_call_instance->ExpectAnyArgsBool = (char)0;
742   CMockExpectParameters_fwk_time_duration_us(cmock_call_instance, duration);
743   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
744          sizeof(fwk_duration_us_t[sizeof(cmock_to_return) == sizeof(fwk_duration_us_t) ? 1 : -1])); /* add fwk_duration_us_t to :treat_as_array if this causes an error */
745 }
746 
fwk_time_duration_us_AddCallback(CMOCK_fwk_time_duration_us_CALLBACK Callback)747 void fwk_time_duration_us_AddCallback(CMOCK_fwk_time_duration_us_CALLBACK Callback)
748 {
749   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
750   Mock.fwk_time_duration_us_CallbackBool = (char)1;
751   Mock.fwk_time_duration_us_CallbackFunctionPointer = Callback;
752 }
753 
fwk_time_duration_us_Stub(CMOCK_fwk_time_duration_us_CALLBACK Callback)754 void fwk_time_duration_us_Stub(CMOCK_fwk_time_duration_us_CALLBACK Callback)
755 {
756   Mock.fwk_time_duration_us_IgnoreBool = (char)0;
757   Mock.fwk_time_duration_us_CallbackBool = (char)0;
758   Mock.fwk_time_duration_us_CallbackFunctionPointer = Callback;
759 }
760 
fwk_time_duration_us_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)761 void fwk_time_duration_us_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)
762 {
763   CMOCK_fwk_time_duration_us_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_us_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_us_CallInstance));
764   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
765   cmock_call_instance->IgnoreArg_duration = 1;
766 }
767 
fwk_time_duration_ms(fwk_duration_ns_t duration)768 fwk_duration_ms_t fwk_time_duration_ms(fwk_duration_ns_t duration)
769 {
770   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
771   CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance;
772   UNITY_SET_DETAIL(CMockString_fwk_time_duration_ms);
773   cmock_call_instance = (CMOCK_fwk_time_duration_ms_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_ms_CallInstance);
774   Mock.fwk_time_duration_ms_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_ms_CallInstance);
775   if (Mock.fwk_time_duration_ms_IgnoreBool)
776   {
777     UNITY_CLR_DETAILS();
778     if (cmock_call_instance == NULL)
779       return Mock.fwk_time_duration_ms_FinalReturn;
780     memcpy((void*)(&Mock.fwk_time_duration_ms_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
781          sizeof(fwk_duration_ms_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_ms_t) ? 1 : -1])); /* add fwk_duration_ms_t to :treat_as_array if this causes an error */
782     return cmock_call_instance->ReturnVal;
783   }
784   if (!Mock.fwk_time_duration_ms_CallbackBool &&
785       Mock.fwk_time_duration_ms_CallbackFunctionPointer != NULL)
786   {
787     fwk_duration_ms_t cmock_cb_ret = Mock.fwk_time_duration_ms_CallbackFunctionPointer(duration, Mock.fwk_time_duration_ms_CallbackCalls++);
788     UNITY_CLR_DETAILS();
789     return cmock_cb_ret;
790   }
791   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
792   cmock_line = cmock_call_instance->LineNumber;
793   if (!cmock_call_instance->ExpectAnyArgsBool)
794   {
795   if (!cmock_call_instance->IgnoreArg_duration)
796   {
797     UNITY_SET_DETAILS(CMockString_fwk_time_duration_ms,CMockString_duration);
798     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration), sizeof(fwk_duration_ns_t), cmock_line, CMockStringMismatch);
799   }
800   }
801   if (Mock.fwk_time_duration_ms_CallbackFunctionPointer != NULL)
802   {
803     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_ms_CallbackFunctionPointer(duration, Mock.fwk_time_duration_ms_CallbackCalls++);
804   }
805   UNITY_CLR_DETAILS();
806   return cmock_call_instance->ReturnVal;
807 }
808 
809 void CMockExpectParameters_fwk_time_duration_ms(CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration);
CMockExpectParameters_fwk_time_duration_ms(CMOCK_fwk_time_duration_ms_CALL_INSTANCE * cmock_call_instance,fwk_duration_ns_t duration)810 void CMockExpectParameters_fwk_time_duration_ms(CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration)
811 {
812   memcpy((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration),
813          sizeof(fwk_duration_ns_t[sizeof(duration) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
814   cmock_call_instance->IgnoreArg_duration = 0;
815 }
816 
fwk_time_duration_ms_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ms_t cmock_to_return)817 void fwk_time_duration_ms_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ms_t cmock_to_return)
818 {
819   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_ms_CALL_INSTANCE));
820   CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_ms_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
821   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
822   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
823   Mock.fwk_time_duration_ms_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_ms_CallInstance, cmock_guts_index);
824   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
825   cmock_call_instance->LineNumber = cmock_line;
826   cmock_call_instance->ExpectAnyArgsBool = (char)0;
827   cmock_call_instance->ReturnVal = cmock_to_return;
828   Mock.fwk_time_duration_ms_IgnoreBool = (char)1;
829 }
830 
fwk_time_duration_ms_CMockStopIgnore(void)831 void fwk_time_duration_ms_CMockStopIgnore(void)
832 {
833   if(Mock.fwk_time_duration_ms_IgnoreBool)
834     Mock.fwk_time_duration_ms_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_ms_CallInstance);
835   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
836 }
837 
fwk_time_duration_ms_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ms_t cmock_to_return)838 void fwk_time_duration_ms_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ms_t cmock_to_return)
839 {
840   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_ms_CALL_INSTANCE));
841   CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_ms_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
842   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
843   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
844   Mock.fwk_time_duration_ms_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_ms_CallInstance, cmock_guts_index);
845   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
846   cmock_call_instance->LineNumber = cmock_line;
847   cmock_call_instance->ExpectAnyArgsBool = (char)0;
848   cmock_call_instance->ReturnVal = cmock_to_return;
849   cmock_call_instance->ExpectAnyArgsBool = (char)1;
850 }
851 
fwk_time_duration_ms_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t duration,fwk_duration_ms_t cmock_to_return)852 void fwk_time_duration_ms_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t duration, fwk_duration_ms_t cmock_to_return)
853 {
854   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_ms_CALL_INSTANCE));
855   CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_ms_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
856   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
857   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
858   Mock.fwk_time_duration_ms_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_ms_CallInstance, cmock_guts_index);
859   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
860   cmock_call_instance->LineNumber = cmock_line;
861   cmock_call_instance->ExpectAnyArgsBool = (char)0;
862   CMockExpectParameters_fwk_time_duration_ms(cmock_call_instance, duration);
863   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
864          sizeof(fwk_duration_ms_t[sizeof(cmock_to_return) == sizeof(fwk_duration_ms_t) ? 1 : -1])); /* add fwk_duration_ms_t to :treat_as_array if this causes an error */
865 }
866 
fwk_time_duration_ms_AddCallback(CMOCK_fwk_time_duration_ms_CALLBACK Callback)867 void fwk_time_duration_ms_AddCallback(CMOCK_fwk_time_duration_ms_CALLBACK Callback)
868 {
869   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
870   Mock.fwk_time_duration_ms_CallbackBool = (char)1;
871   Mock.fwk_time_duration_ms_CallbackFunctionPointer = Callback;
872 }
873 
fwk_time_duration_ms_Stub(CMOCK_fwk_time_duration_ms_CALLBACK Callback)874 void fwk_time_duration_ms_Stub(CMOCK_fwk_time_duration_ms_CALLBACK Callback)
875 {
876   Mock.fwk_time_duration_ms_IgnoreBool = (char)0;
877   Mock.fwk_time_duration_ms_CallbackBool = (char)0;
878   Mock.fwk_time_duration_ms_CallbackFunctionPointer = Callback;
879 }
880 
fwk_time_duration_ms_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)881 void fwk_time_duration_ms_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)
882 {
883   CMOCK_fwk_time_duration_ms_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_ms_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_ms_CallInstance));
884   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
885   cmock_call_instance->IgnoreArg_duration = 1;
886 }
887 
fwk_time_duration_s(fwk_duration_ns_t duration)888 fwk_duration_s_t fwk_time_duration_s(fwk_duration_ns_t duration)
889 {
890   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
891   CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance;
892   UNITY_SET_DETAIL(CMockString_fwk_time_duration_s);
893   cmock_call_instance = (CMOCK_fwk_time_duration_s_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_s_CallInstance);
894   Mock.fwk_time_duration_s_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_s_CallInstance);
895   if (Mock.fwk_time_duration_s_IgnoreBool)
896   {
897     UNITY_CLR_DETAILS();
898     if (cmock_call_instance == NULL)
899       return Mock.fwk_time_duration_s_FinalReturn;
900     memcpy((void*)(&Mock.fwk_time_duration_s_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
901          sizeof(fwk_duration_s_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_s_t) ? 1 : -1])); /* add fwk_duration_s_t to :treat_as_array if this causes an error */
902     return cmock_call_instance->ReturnVal;
903   }
904   if (!Mock.fwk_time_duration_s_CallbackBool &&
905       Mock.fwk_time_duration_s_CallbackFunctionPointer != NULL)
906   {
907     fwk_duration_s_t cmock_cb_ret = Mock.fwk_time_duration_s_CallbackFunctionPointer(duration, Mock.fwk_time_duration_s_CallbackCalls++);
908     UNITY_CLR_DETAILS();
909     return cmock_cb_ret;
910   }
911   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
912   cmock_line = cmock_call_instance->LineNumber;
913   if (!cmock_call_instance->ExpectAnyArgsBool)
914   {
915   if (!cmock_call_instance->IgnoreArg_duration)
916   {
917     UNITY_SET_DETAILS(CMockString_fwk_time_duration_s,CMockString_duration);
918     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration), sizeof(fwk_duration_ns_t), cmock_line, CMockStringMismatch);
919   }
920   }
921   if (Mock.fwk_time_duration_s_CallbackFunctionPointer != NULL)
922   {
923     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_s_CallbackFunctionPointer(duration, Mock.fwk_time_duration_s_CallbackCalls++);
924   }
925   UNITY_CLR_DETAILS();
926   return cmock_call_instance->ReturnVal;
927 }
928 
929 void CMockExpectParameters_fwk_time_duration_s(CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration);
CMockExpectParameters_fwk_time_duration_s(CMOCK_fwk_time_duration_s_CALL_INSTANCE * cmock_call_instance,fwk_duration_ns_t duration)930 void CMockExpectParameters_fwk_time_duration_s(CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration)
931 {
932   memcpy((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration),
933          sizeof(fwk_duration_ns_t[sizeof(duration) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
934   cmock_call_instance->IgnoreArg_duration = 0;
935 }
936 
fwk_time_duration_s_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_s_t cmock_to_return)937 void fwk_time_duration_s_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_s_t cmock_to_return)
938 {
939   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_s_CALL_INSTANCE));
940   CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_s_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
941   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
942   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
943   Mock.fwk_time_duration_s_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_s_CallInstance, cmock_guts_index);
944   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
945   cmock_call_instance->LineNumber = cmock_line;
946   cmock_call_instance->ExpectAnyArgsBool = (char)0;
947   cmock_call_instance->ReturnVal = cmock_to_return;
948   Mock.fwk_time_duration_s_IgnoreBool = (char)1;
949 }
950 
fwk_time_duration_s_CMockStopIgnore(void)951 void fwk_time_duration_s_CMockStopIgnore(void)
952 {
953   if(Mock.fwk_time_duration_s_IgnoreBool)
954     Mock.fwk_time_duration_s_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_s_CallInstance);
955   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
956 }
957 
fwk_time_duration_s_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_s_t cmock_to_return)958 void fwk_time_duration_s_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_s_t cmock_to_return)
959 {
960   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_s_CALL_INSTANCE));
961   CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_s_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
962   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
963   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
964   Mock.fwk_time_duration_s_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_s_CallInstance, cmock_guts_index);
965   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
966   cmock_call_instance->LineNumber = cmock_line;
967   cmock_call_instance->ExpectAnyArgsBool = (char)0;
968   cmock_call_instance->ReturnVal = cmock_to_return;
969   cmock_call_instance->ExpectAnyArgsBool = (char)1;
970 }
971 
fwk_time_duration_s_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t duration,fwk_duration_s_t cmock_to_return)972 void fwk_time_duration_s_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t duration, fwk_duration_s_t cmock_to_return)
973 {
974   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_s_CALL_INSTANCE));
975   CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_s_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
976   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
977   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
978   Mock.fwk_time_duration_s_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_s_CallInstance, cmock_guts_index);
979   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
980   cmock_call_instance->LineNumber = cmock_line;
981   cmock_call_instance->ExpectAnyArgsBool = (char)0;
982   CMockExpectParameters_fwk_time_duration_s(cmock_call_instance, duration);
983   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
984          sizeof(fwk_duration_s_t[sizeof(cmock_to_return) == sizeof(fwk_duration_s_t) ? 1 : -1])); /* add fwk_duration_s_t to :treat_as_array if this causes an error */
985 }
986 
fwk_time_duration_s_AddCallback(CMOCK_fwk_time_duration_s_CALLBACK Callback)987 void fwk_time_duration_s_AddCallback(CMOCK_fwk_time_duration_s_CALLBACK Callback)
988 {
989   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
990   Mock.fwk_time_duration_s_CallbackBool = (char)1;
991   Mock.fwk_time_duration_s_CallbackFunctionPointer = Callback;
992 }
993 
fwk_time_duration_s_Stub(CMOCK_fwk_time_duration_s_CALLBACK Callback)994 void fwk_time_duration_s_Stub(CMOCK_fwk_time_duration_s_CALLBACK Callback)
995 {
996   Mock.fwk_time_duration_s_IgnoreBool = (char)0;
997   Mock.fwk_time_duration_s_CallbackBool = (char)0;
998   Mock.fwk_time_duration_s_CallbackFunctionPointer = Callback;
999 }
1000 
fwk_time_duration_s_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)1001 void fwk_time_duration_s_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)
1002 {
1003   CMOCK_fwk_time_duration_s_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_s_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_s_CallInstance));
1004   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1005   cmock_call_instance->IgnoreArg_duration = 1;
1006 }
1007 
fwk_time_duration_m(fwk_duration_ns_t duration)1008 fwk_duration_m_t fwk_time_duration_m(fwk_duration_ns_t duration)
1009 {
1010   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1011   CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance;
1012   UNITY_SET_DETAIL(CMockString_fwk_time_duration_m);
1013   cmock_call_instance = (CMOCK_fwk_time_duration_m_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_m_CallInstance);
1014   Mock.fwk_time_duration_m_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_m_CallInstance);
1015   if (Mock.fwk_time_duration_m_IgnoreBool)
1016   {
1017     UNITY_CLR_DETAILS();
1018     if (cmock_call_instance == NULL)
1019       return Mock.fwk_time_duration_m_FinalReturn;
1020     memcpy((void*)(&Mock.fwk_time_duration_m_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
1021          sizeof(fwk_duration_m_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_m_t) ? 1 : -1])); /* add fwk_duration_m_t to :treat_as_array if this causes an error */
1022     return cmock_call_instance->ReturnVal;
1023   }
1024   if (!Mock.fwk_time_duration_m_CallbackBool &&
1025       Mock.fwk_time_duration_m_CallbackFunctionPointer != NULL)
1026   {
1027     fwk_duration_m_t cmock_cb_ret = Mock.fwk_time_duration_m_CallbackFunctionPointer(duration, Mock.fwk_time_duration_m_CallbackCalls++);
1028     UNITY_CLR_DETAILS();
1029     return cmock_cb_ret;
1030   }
1031   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1032   cmock_line = cmock_call_instance->LineNumber;
1033   if (!cmock_call_instance->ExpectAnyArgsBool)
1034   {
1035   if (!cmock_call_instance->IgnoreArg_duration)
1036   {
1037     UNITY_SET_DETAILS(CMockString_fwk_time_duration_m,CMockString_duration);
1038     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration), sizeof(fwk_duration_ns_t), cmock_line, CMockStringMismatch);
1039   }
1040   }
1041   if (Mock.fwk_time_duration_m_CallbackFunctionPointer != NULL)
1042   {
1043     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_m_CallbackFunctionPointer(duration, Mock.fwk_time_duration_m_CallbackCalls++);
1044   }
1045   UNITY_CLR_DETAILS();
1046   return cmock_call_instance->ReturnVal;
1047 }
1048 
1049 void CMockExpectParameters_fwk_time_duration_m(CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration);
CMockExpectParameters_fwk_time_duration_m(CMOCK_fwk_time_duration_m_CALL_INSTANCE * cmock_call_instance,fwk_duration_ns_t duration)1050 void CMockExpectParameters_fwk_time_duration_m(CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration)
1051 {
1052   memcpy((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration),
1053          sizeof(fwk_duration_ns_t[sizeof(duration) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
1054   cmock_call_instance->IgnoreArg_duration = 0;
1055 }
1056 
fwk_time_duration_m_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_m_t cmock_to_return)1057 void fwk_time_duration_m_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_m_t cmock_to_return)
1058 {
1059   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_m_CALL_INSTANCE));
1060   CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_m_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1061   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1062   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1063   Mock.fwk_time_duration_m_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_m_CallInstance, cmock_guts_index);
1064   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1065   cmock_call_instance->LineNumber = cmock_line;
1066   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1067   cmock_call_instance->ReturnVal = cmock_to_return;
1068   Mock.fwk_time_duration_m_IgnoreBool = (char)1;
1069 }
1070 
fwk_time_duration_m_CMockStopIgnore(void)1071 void fwk_time_duration_m_CMockStopIgnore(void)
1072 {
1073   if(Mock.fwk_time_duration_m_IgnoreBool)
1074     Mock.fwk_time_duration_m_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_m_CallInstance);
1075   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1076 }
1077 
fwk_time_duration_m_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_m_t cmock_to_return)1078 void fwk_time_duration_m_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_m_t cmock_to_return)
1079 {
1080   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_m_CALL_INSTANCE));
1081   CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_m_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1082   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1083   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1084   Mock.fwk_time_duration_m_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_m_CallInstance, cmock_guts_index);
1085   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1086   cmock_call_instance->LineNumber = cmock_line;
1087   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1088   cmock_call_instance->ReturnVal = cmock_to_return;
1089   cmock_call_instance->ExpectAnyArgsBool = (char)1;
1090 }
1091 
fwk_time_duration_m_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t duration,fwk_duration_m_t cmock_to_return)1092 void fwk_time_duration_m_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t duration, fwk_duration_m_t cmock_to_return)
1093 {
1094   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_m_CALL_INSTANCE));
1095   CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_m_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1096   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1097   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1098   Mock.fwk_time_duration_m_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_m_CallInstance, cmock_guts_index);
1099   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1100   cmock_call_instance->LineNumber = cmock_line;
1101   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1102   CMockExpectParameters_fwk_time_duration_m(cmock_call_instance, duration);
1103   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
1104          sizeof(fwk_duration_m_t[sizeof(cmock_to_return) == sizeof(fwk_duration_m_t) ? 1 : -1])); /* add fwk_duration_m_t to :treat_as_array if this causes an error */
1105 }
1106 
fwk_time_duration_m_AddCallback(CMOCK_fwk_time_duration_m_CALLBACK Callback)1107 void fwk_time_duration_m_AddCallback(CMOCK_fwk_time_duration_m_CALLBACK Callback)
1108 {
1109   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1110   Mock.fwk_time_duration_m_CallbackBool = (char)1;
1111   Mock.fwk_time_duration_m_CallbackFunctionPointer = Callback;
1112 }
1113 
fwk_time_duration_m_Stub(CMOCK_fwk_time_duration_m_CALLBACK Callback)1114 void fwk_time_duration_m_Stub(CMOCK_fwk_time_duration_m_CALLBACK Callback)
1115 {
1116   Mock.fwk_time_duration_m_IgnoreBool = (char)0;
1117   Mock.fwk_time_duration_m_CallbackBool = (char)0;
1118   Mock.fwk_time_duration_m_CallbackFunctionPointer = Callback;
1119 }
1120 
fwk_time_duration_m_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)1121 void fwk_time_duration_m_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)
1122 {
1123   CMOCK_fwk_time_duration_m_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_m_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_m_CallInstance));
1124   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1125   cmock_call_instance->IgnoreArg_duration = 1;
1126 }
1127 
fwk_time_duration_h(fwk_duration_ns_t duration)1128 fwk_duration_h_t fwk_time_duration_h(fwk_duration_ns_t duration)
1129 {
1130   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1131   CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance;
1132   UNITY_SET_DETAIL(CMockString_fwk_time_duration_h);
1133   cmock_call_instance = (CMOCK_fwk_time_duration_h_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_time_duration_h_CallInstance);
1134   Mock.fwk_time_duration_h_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_h_CallInstance);
1135   if (Mock.fwk_time_duration_h_IgnoreBool)
1136   {
1137     UNITY_CLR_DETAILS();
1138     if (cmock_call_instance == NULL)
1139       return Mock.fwk_time_duration_h_FinalReturn;
1140     memcpy((void*)(&Mock.fwk_time_duration_h_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
1141          sizeof(fwk_duration_h_t[sizeof(cmock_call_instance->ReturnVal) == sizeof(fwk_duration_h_t) ? 1 : -1])); /* add fwk_duration_h_t to :treat_as_array if this causes an error */
1142     return cmock_call_instance->ReturnVal;
1143   }
1144   if (!Mock.fwk_time_duration_h_CallbackBool &&
1145       Mock.fwk_time_duration_h_CallbackFunctionPointer != NULL)
1146   {
1147     fwk_duration_h_t cmock_cb_ret = Mock.fwk_time_duration_h_CallbackFunctionPointer(duration, Mock.fwk_time_duration_h_CallbackCalls++);
1148     UNITY_CLR_DETAILS();
1149     return cmock_cb_ret;
1150   }
1151   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1152   cmock_line = cmock_call_instance->LineNumber;
1153   if (!cmock_call_instance->ExpectAnyArgsBool)
1154   {
1155   if (!cmock_call_instance->IgnoreArg_duration)
1156   {
1157     UNITY_SET_DETAILS(CMockString_fwk_time_duration_h,CMockString_duration);
1158     UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration), sizeof(fwk_duration_ns_t), cmock_line, CMockStringMismatch);
1159   }
1160   }
1161   if (Mock.fwk_time_duration_h_CallbackFunctionPointer != NULL)
1162   {
1163     cmock_call_instance->ReturnVal = Mock.fwk_time_duration_h_CallbackFunctionPointer(duration, Mock.fwk_time_duration_h_CallbackCalls++);
1164   }
1165   UNITY_CLR_DETAILS();
1166   return cmock_call_instance->ReturnVal;
1167 }
1168 
1169 void CMockExpectParameters_fwk_time_duration_h(CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration);
CMockExpectParameters_fwk_time_duration_h(CMOCK_fwk_time_duration_h_CALL_INSTANCE * cmock_call_instance,fwk_duration_ns_t duration)1170 void CMockExpectParameters_fwk_time_duration_h(CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance, fwk_duration_ns_t duration)
1171 {
1172   memcpy((void*)(&cmock_call_instance->Expected_duration), (void*)(&duration),
1173          sizeof(fwk_duration_ns_t[sizeof(duration) == sizeof(fwk_duration_ns_t) ? 1 : -1])); /* add fwk_duration_ns_t to :treat_as_array if this causes an error */
1174   cmock_call_instance->IgnoreArg_duration = 0;
1175 }
1176 
fwk_time_duration_h_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_h_t cmock_to_return)1177 void fwk_time_duration_h_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_h_t cmock_to_return)
1178 {
1179   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_h_CALL_INSTANCE));
1180   CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_h_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1181   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1182   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1183   Mock.fwk_time_duration_h_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_h_CallInstance, cmock_guts_index);
1184   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1185   cmock_call_instance->LineNumber = cmock_line;
1186   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1187   cmock_call_instance->ReturnVal = cmock_to_return;
1188   Mock.fwk_time_duration_h_IgnoreBool = (char)1;
1189 }
1190 
fwk_time_duration_h_CMockStopIgnore(void)1191 void fwk_time_duration_h_CMockStopIgnore(void)
1192 {
1193   if(Mock.fwk_time_duration_h_IgnoreBool)
1194     Mock.fwk_time_duration_h_CallInstance = CMock_Guts_MemNext(Mock.fwk_time_duration_h_CallInstance);
1195   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1196 }
1197 
fwk_time_duration_h_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_h_t cmock_to_return)1198 void fwk_time_duration_h_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_h_t cmock_to_return)
1199 {
1200   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_h_CALL_INSTANCE));
1201   CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_h_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1202   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1203   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1204   Mock.fwk_time_duration_h_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_h_CallInstance, cmock_guts_index);
1205   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1206   cmock_call_instance->LineNumber = cmock_line;
1207   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1208   cmock_call_instance->ReturnVal = cmock_to_return;
1209   cmock_call_instance->ExpectAnyArgsBool = (char)1;
1210 }
1211 
fwk_time_duration_h_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,fwk_duration_ns_t duration,fwk_duration_h_t cmock_to_return)1212 void fwk_time_duration_h_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, fwk_duration_ns_t duration, fwk_duration_h_t cmock_to_return)
1213 {
1214   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_time_duration_h_CALL_INSTANCE));
1215   CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_h_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1216   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1217   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1218   Mock.fwk_time_duration_h_CallInstance = CMock_Guts_MemChain(Mock.fwk_time_duration_h_CallInstance, cmock_guts_index);
1219   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1220   cmock_call_instance->LineNumber = cmock_line;
1221   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1222   CMockExpectParameters_fwk_time_duration_h(cmock_call_instance, duration);
1223   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
1224          sizeof(fwk_duration_h_t[sizeof(cmock_to_return) == sizeof(fwk_duration_h_t) ? 1 : -1])); /* add fwk_duration_h_t to :treat_as_array if this causes an error */
1225 }
1226 
fwk_time_duration_h_AddCallback(CMOCK_fwk_time_duration_h_CALLBACK Callback)1227 void fwk_time_duration_h_AddCallback(CMOCK_fwk_time_duration_h_CALLBACK Callback)
1228 {
1229   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1230   Mock.fwk_time_duration_h_CallbackBool = (char)1;
1231   Mock.fwk_time_duration_h_CallbackFunctionPointer = Callback;
1232 }
1233 
fwk_time_duration_h_Stub(CMOCK_fwk_time_duration_h_CALLBACK Callback)1234 void fwk_time_duration_h_Stub(CMOCK_fwk_time_duration_h_CALLBACK Callback)
1235 {
1236   Mock.fwk_time_duration_h_IgnoreBool = (char)0;
1237   Mock.fwk_time_duration_h_CallbackBool = (char)0;
1238   Mock.fwk_time_duration_h_CallbackFunctionPointer = Callback;
1239 }
1240 
fwk_time_duration_h_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)1241 void fwk_time_duration_h_CMockIgnoreArg_duration(UNITY_LINE_TYPE cmock_line)
1242 {
1243   CMOCK_fwk_time_duration_h_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_time_duration_h_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_time_duration_h_CallInstance));
1244   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1245   cmock_call_instance->IgnoreArg_duration = 1;
1246 }
1247 
fmw_time_driver(const void ** ctx)1248 struct fwk_time_driver fmw_time_driver(const void** ctx)
1249 {
1250   UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1251   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance;
1252   UNITY_SET_DETAIL(CMockString_fmw_time_driver);
1253   cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fmw_time_driver_CallInstance);
1254   Mock.fmw_time_driver_CallInstance = CMock_Guts_MemNext(Mock.fmw_time_driver_CallInstance);
1255   if (Mock.fmw_time_driver_IgnoreBool)
1256   {
1257     UNITY_CLR_DETAILS();
1258     if (cmock_call_instance == NULL)
1259       return Mock.fmw_time_driver_FinalReturn;
1260     memcpy((void*)(&Mock.fmw_time_driver_FinalReturn), (void*)(&cmock_call_instance->ReturnVal),
1261          sizeof(struct fwk_time_driver[sizeof(cmock_call_instance->ReturnVal) == sizeof(struct fwk_time_driver) ? 1 : -1])); /* add struct fwk_time_driver to :treat_as_array if this causes an error */
1262     return cmock_call_instance->ReturnVal;
1263   }
1264   if (!Mock.fmw_time_driver_CallbackBool &&
1265       Mock.fmw_time_driver_CallbackFunctionPointer != NULL)
1266   {
1267     struct fwk_time_driver cmock_cb_ret = Mock.fmw_time_driver_CallbackFunctionPointer(ctx, Mock.fmw_time_driver_CallbackCalls++);
1268     UNITY_CLR_DETAILS();
1269     return cmock_cb_ret;
1270   }
1271   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1272   cmock_line = cmock_call_instance->LineNumber;
1273   if (!cmock_call_instance->ExpectAnyArgsBool)
1274   {
1275   if (!cmock_call_instance->IgnoreArg_ctx)
1276   {
1277     UNITY_SET_DETAILS(CMockString_fmw_time_driver,CMockString_ctx);
1278     UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_ctx, ctx, cmock_line, CMockStringMismatch);
1279   }
1280   }
1281   if (Mock.fmw_time_driver_CallbackFunctionPointer != NULL)
1282   {
1283     cmock_call_instance->ReturnVal = Mock.fmw_time_driver_CallbackFunctionPointer(ctx, Mock.fmw_time_driver_CallbackCalls++);
1284   }
1285   if (cmock_call_instance->ReturnThruPtr_ctx_Used)
1286   {
1287     UNITY_TEST_ASSERT_NOT_NULL(ctx, cmock_line, CMockStringPtrIsNULL);
1288     memcpy((void*)ctx, (void*)cmock_call_instance->ReturnThruPtr_ctx_Val,
1289       cmock_call_instance->ReturnThruPtr_ctx_Size);
1290   }
1291   UNITY_CLR_DETAILS();
1292   return cmock_call_instance->ReturnVal;
1293 }
1294 
1295 void CMockExpectParameters_fmw_time_driver(CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance, const void** ctx, int ctx_Depth);
CMockExpectParameters_fmw_time_driver(CMOCK_fmw_time_driver_CALL_INSTANCE * cmock_call_instance,const void ** ctx,int ctx_Depth)1296 void CMockExpectParameters_fmw_time_driver(CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance, const void** ctx, int ctx_Depth)
1297 {
1298   cmock_call_instance->Expected_ctx = ctx;
1299   cmock_call_instance->Expected_ctx_Depth = ctx_Depth;
1300   cmock_call_instance->IgnoreArg_ctx = 0;
1301   cmock_call_instance->ReturnThruPtr_ctx_Used = 0;
1302 }
1303 
fmw_time_driver_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,struct fwk_time_driver cmock_to_return)1304 void fmw_time_driver_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, struct fwk_time_driver cmock_to_return)
1305 {
1306   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fmw_time_driver_CALL_INSTANCE));
1307   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1308   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1309   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1310   Mock.fmw_time_driver_CallInstance = CMock_Guts_MemChain(Mock.fmw_time_driver_CallInstance, cmock_guts_index);
1311   Mock.fmw_time_driver_IgnoreBool = (char)0;
1312   cmock_call_instance->LineNumber = cmock_line;
1313   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1314   cmock_call_instance->ReturnVal = cmock_to_return;
1315   Mock.fmw_time_driver_IgnoreBool = (char)1;
1316 }
1317 
fmw_time_driver_CMockStopIgnore(void)1318 void fmw_time_driver_CMockStopIgnore(void)
1319 {
1320   if(Mock.fmw_time_driver_IgnoreBool)
1321     Mock.fmw_time_driver_CallInstance = CMock_Guts_MemNext(Mock.fmw_time_driver_CallInstance);
1322   Mock.fmw_time_driver_IgnoreBool = (char)0;
1323 }
1324 
fmw_time_driver_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,struct fwk_time_driver cmock_to_return)1325 void fmw_time_driver_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, struct fwk_time_driver cmock_to_return)
1326 {
1327   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fmw_time_driver_CALL_INSTANCE));
1328   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1329   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1330   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1331   Mock.fmw_time_driver_CallInstance = CMock_Guts_MemChain(Mock.fmw_time_driver_CallInstance, cmock_guts_index);
1332   Mock.fmw_time_driver_IgnoreBool = (char)0;
1333   cmock_call_instance->LineNumber = cmock_line;
1334   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1335   cmock_call_instance->ReturnVal = cmock_to_return;
1336   cmock_call_instance->ExpectAnyArgsBool = (char)1;
1337 }
1338 
fmw_time_driver_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,const void ** ctx,struct fwk_time_driver cmock_to_return)1339 void fmw_time_driver_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const void** ctx, struct fwk_time_driver cmock_to_return)
1340 {
1341   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fmw_time_driver_CALL_INSTANCE));
1342   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1343   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1344   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1345   Mock.fmw_time_driver_CallInstance = CMock_Guts_MemChain(Mock.fmw_time_driver_CallInstance, cmock_guts_index);
1346   Mock.fmw_time_driver_IgnoreBool = (char)0;
1347   cmock_call_instance->LineNumber = cmock_line;
1348   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1349   CMockExpectParameters_fmw_time_driver(cmock_call_instance, ctx, 1);
1350   memcpy((void*)(&cmock_call_instance->ReturnVal), (void*)(&cmock_to_return),
1351          sizeof(struct fwk_time_driver[sizeof(cmock_to_return) == sizeof(struct fwk_time_driver) ? 1 : -1])); /* add struct fwk_time_driver to :treat_as_array if this causes an error */
1352 }
1353 
fmw_time_driver_AddCallback(CMOCK_fmw_time_driver_CALLBACK Callback)1354 void fmw_time_driver_AddCallback(CMOCK_fmw_time_driver_CALLBACK Callback)
1355 {
1356   Mock.fmw_time_driver_IgnoreBool = (char)0;
1357   Mock.fmw_time_driver_CallbackBool = (char)1;
1358   Mock.fmw_time_driver_CallbackFunctionPointer = Callback;
1359 }
1360 
fmw_time_driver_Stub(CMOCK_fmw_time_driver_CALLBACK Callback)1361 void fmw_time_driver_Stub(CMOCK_fmw_time_driver_CALLBACK Callback)
1362 {
1363   Mock.fmw_time_driver_IgnoreBool = (char)0;
1364   Mock.fmw_time_driver_CallbackBool = (char)0;
1365   Mock.fmw_time_driver_CallbackFunctionPointer = Callback;
1366 }
1367 
fmw_time_driver_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line,const void ** ctx,int ctx_Depth,struct fwk_time_driver cmock_to_return)1368 void fmw_time_driver_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, const void** ctx, int ctx_Depth, struct fwk_time_driver cmock_to_return)
1369 {
1370   CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fmw_time_driver_CALL_INSTANCE));
1371   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1372   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1373   memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1374   Mock.fmw_time_driver_CallInstance = CMock_Guts_MemChain(Mock.fmw_time_driver_CallInstance, cmock_guts_index);
1375   Mock.fmw_time_driver_IgnoreBool = (char)0;
1376   cmock_call_instance->LineNumber = cmock_line;
1377   cmock_call_instance->ExpectAnyArgsBool = (char)0;
1378   CMockExpectParameters_fmw_time_driver(cmock_call_instance, ctx, ctx_Depth);
1379   cmock_call_instance->ReturnVal = cmock_to_return;
1380 }
1381 
fmw_time_driver_CMockReturnMemThruPtr_ctx(UNITY_LINE_TYPE cmock_line,const void ** ctx,size_t cmock_size)1382 void fmw_time_driver_CMockReturnMemThruPtr_ctx(UNITY_LINE_TYPE cmock_line, const void** ctx, size_t cmock_size)
1383 {
1384   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fmw_time_driver_CallInstance));
1385   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
1386   cmock_call_instance->ReturnThruPtr_ctx_Used = 1;
1387   cmock_call_instance->ReturnThruPtr_ctx_Val = ctx;
1388   cmock_call_instance->ReturnThruPtr_ctx_Size = cmock_size;
1389 }
1390 
fmw_time_driver_CMockIgnoreArg_ctx(UNITY_LINE_TYPE cmock_line)1391 void fmw_time_driver_CMockIgnoreArg_ctx(UNITY_LINE_TYPE cmock_line)
1392 {
1393   CMOCK_fmw_time_driver_CALL_INSTANCE* cmock_call_instance = (CMOCK_fmw_time_driver_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fmw_time_driver_CallInstance));
1394   UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1395   cmock_call_instance->IgnoreArg_ctx = 1;
1396 }
1397 
1398