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_interrupt.h"
7
8 static const char* CMockString_driver = "driver";
9 static const char* CMockString_enabled = "enabled";
10 static const char* CMockString_fwk_interrupt_clear_pending = "fwk_interrupt_clear_pending";
11 static const char* CMockString_fwk_interrupt_disable = "fwk_interrupt_disable";
12 static const char* CMockString_fwk_interrupt_enable = "fwk_interrupt_enable";
13 static const char* CMockString_fwk_interrupt_get_current = "fwk_interrupt_get_current";
14 static const char* CMockString_fwk_interrupt_init = "fwk_interrupt_init";
15 static const char* CMockString_fwk_interrupt_is_enabled = "fwk_interrupt_is_enabled";
16 static const char* CMockString_fwk_interrupt_is_pending = "fwk_interrupt_is_pending";
17 static const char* CMockString_fwk_interrupt_set_isr = "fwk_interrupt_set_isr";
18 static const char* CMockString_fwk_interrupt_set_isr_param = "fwk_interrupt_set_isr_param";
19 static const char* CMockString_fwk_interrupt_set_pending = "fwk_interrupt_set_pending";
20 static const char* CMockString_fwk_is_interrupt_context = "fwk_is_interrupt_context";
21 static const char* CMockString_interrupt = "interrupt";
22 static const char* CMockString_isr = "isr";
23 static const char* CMockString_param = "param";
24 static const char* CMockString_pending = "pending";
25
26 typedef struct _CMOCK_fwk_interrupt_init_CALL_INSTANCE
27 {
28 UNITY_LINE_TYPE LineNumber;
29 char ExpectAnyArgsBool;
30 int ReturnVal;
31 const struct fwk_arch_interrupt_driver* Expected_driver;
32 int Expected_driver_Depth;
33 char IgnoreArg_driver;
34
35 } CMOCK_fwk_interrupt_init_CALL_INSTANCE;
36
37 typedef struct _CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE
38 {
39 UNITY_LINE_TYPE LineNumber;
40 char ExpectAnyArgsBool;
41 int ReturnVal;
42 unsigned int Expected_interrupt;
43 bool* Expected_enabled;
44 int Expected_enabled_Depth;
45 char ReturnThruPtr_enabled_Used;
46 bool* ReturnThruPtr_enabled_Val;
47 size_t ReturnThruPtr_enabled_Size;
48 char IgnoreArg_interrupt;
49 char IgnoreArg_enabled;
50
51 } CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE;
52
53 typedef struct _CMOCK_fwk_interrupt_enable_CALL_INSTANCE
54 {
55 UNITY_LINE_TYPE LineNumber;
56 char ExpectAnyArgsBool;
57 int ReturnVal;
58 unsigned int Expected_interrupt;
59 char IgnoreArg_interrupt;
60
61 } CMOCK_fwk_interrupt_enable_CALL_INSTANCE;
62
63 typedef struct _CMOCK_fwk_interrupt_disable_CALL_INSTANCE
64 {
65 UNITY_LINE_TYPE LineNumber;
66 char ExpectAnyArgsBool;
67 int ReturnVal;
68 unsigned int Expected_interrupt;
69 char IgnoreArg_interrupt;
70
71 } CMOCK_fwk_interrupt_disable_CALL_INSTANCE;
72
73 typedef struct _CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE
74 {
75 UNITY_LINE_TYPE LineNumber;
76 char ExpectAnyArgsBool;
77 int ReturnVal;
78 unsigned int Expected_interrupt;
79 bool* Expected_pending;
80 int Expected_pending_Depth;
81 char ReturnThruPtr_pending_Used;
82 bool* ReturnThruPtr_pending_Val;
83 size_t ReturnThruPtr_pending_Size;
84 char IgnoreArg_interrupt;
85 char IgnoreArg_pending;
86
87 } CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE;
88
89 typedef struct _CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE
90 {
91 UNITY_LINE_TYPE LineNumber;
92 char ExpectAnyArgsBool;
93 int ReturnVal;
94 unsigned int Expected_interrupt;
95 char IgnoreArg_interrupt;
96
97 } CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE;
98
99 typedef struct _CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE
100 {
101 UNITY_LINE_TYPE LineNumber;
102 char ExpectAnyArgsBool;
103 int ReturnVal;
104 unsigned int Expected_interrupt;
105 char IgnoreArg_interrupt;
106
107 } CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE;
108
109 typedef struct _CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE
110 {
111 UNITY_LINE_TYPE LineNumber;
112 char ExpectAnyArgsBool;
113 int ReturnVal;
114 unsigned int Expected_interrupt;
115 cmock_fwk_interrupt_func_ptr1 Expected_isr;
116 char IgnoreArg_interrupt;
117 char IgnoreArg_isr;
118
119 } CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE;
120
121 typedef struct _CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE
122 {
123 UNITY_LINE_TYPE LineNumber;
124 char ExpectAnyArgsBool;
125 int ReturnVal;
126 unsigned int Expected_interrupt;
127 cmock_fwk_interrupt_func_ptr2 Expected_isr;
128 uintptr_t Expected_param;
129 char IgnoreArg_interrupt;
130 char IgnoreArg_isr;
131 char IgnoreArg_param;
132
133 } CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE;
134
135 typedef struct _CMOCK_fwk_interrupt_get_current_CALL_INSTANCE
136 {
137 UNITY_LINE_TYPE LineNumber;
138 char ExpectAnyArgsBool;
139 int ReturnVal;
140 unsigned int* Expected_interrupt;
141 int Expected_interrupt_Depth;
142 char ReturnThruPtr_interrupt_Used;
143 unsigned int* ReturnThruPtr_interrupt_Val;
144 size_t ReturnThruPtr_interrupt_Size;
145 char IgnoreArg_interrupt;
146
147 } CMOCK_fwk_interrupt_get_current_CALL_INSTANCE;
148
149 typedef struct _CMOCK_fwk_is_interrupt_context_CALL_INSTANCE
150 {
151 UNITY_LINE_TYPE LineNumber;
152 char ExpectAnyArgsBool;
153 bool ReturnVal;
154
155 } CMOCK_fwk_is_interrupt_context_CALL_INSTANCE;
156
157 static struct Mockfwk_interruptInstance
158 {
159 char fwk_interrupt_init_IgnoreBool;
160 int fwk_interrupt_init_FinalReturn;
161 char fwk_interrupt_init_CallbackBool;
162 CMOCK_fwk_interrupt_init_CALLBACK fwk_interrupt_init_CallbackFunctionPointer;
163 int fwk_interrupt_init_CallbackCalls;
164 CMOCK_MEM_INDEX_TYPE fwk_interrupt_init_CallInstance;
165 char fwk_interrupt_is_enabled_IgnoreBool;
166 int fwk_interrupt_is_enabled_FinalReturn;
167 char fwk_interrupt_is_enabled_CallbackBool;
168 CMOCK_fwk_interrupt_is_enabled_CALLBACK fwk_interrupt_is_enabled_CallbackFunctionPointer;
169 int fwk_interrupt_is_enabled_CallbackCalls;
170 CMOCK_MEM_INDEX_TYPE fwk_interrupt_is_enabled_CallInstance;
171 char fwk_interrupt_enable_IgnoreBool;
172 int fwk_interrupt_enable_FinalReturn;
173 char fwk_interrupt_enable_CallbackBool;
174 CMOCK_fwk_interrupt_enable_CALLBACK fwk_interrupt_enable_CallbackFunctionPointer;
175 int fwk_interrupt_enable_CallbackCalls;
176 CMOCK_MEM_INDEX_TYPE fwk_interrupt_enable_CallInstance;
177 char fwk_interrupt_disable_IgnoreBool;
178 int fwk_interrupt_disable_FinalReturn;
179 char fwk_interrupt_disable_CallbackBool;
180 CMOCK_fwk_interrupt_disable_CALLBACK fwk_interrupt_disable_CallbackFunctionPointer;
181 int fwk_interrupt_disable_CallbackCalls;
182 CMOCK_MEM_INDEX_TYPE fwk_interrupt_disable_CallInstance;
183 char fwk_interrupt_is_pending_IgnoreBool;
184 int fwk_interrupt_is_pending_FinalReturn;
185 char fwk_interrupt_is_pending_CallbackBool;
186 CMOCK_fwk_interrupt_is_pending_CALLBACK fwk_interrupt_is_pending_CallbackFunctionPointer;
187 int fwk_interrupt_is_pending_CallbackCalls;
188 CMOCK_MEM_INDEX_TYPE fwk_interrupt_is_pending_CallInstance;
189 char fwk_interrupt_set_pending_IgnoreBool;
190 int fwk_interrupt_set_pending_FinalReturn;
191 char fwk_interrupt_set_pending_CallbackBool;
192 CMOCK_fwk_interrupt_set_pending_CALLBACK fwk_interrupt_set_pending_CallbackFunctionPointer;
193 int fwk_interrupt_set_pending_CallbackCalls;
194 CMOCK_MEM_INDEX_TYPE fwk_interrupt_set_pending_CallInstance;
195 char fwk_interrupt_clear_pending_IgnoreBool;
196 int fwk_interrupt_clear_pending_FinalReturn;
197 char fwk_interrupt_clear_pending_CallbackBool;
198 CMOCK_fwk_interrupt_clear_pending_CALLBACK fwk_interrupt_clear_pending_CallbackFunctionPointer;
199 int fwk_interrupt_clear_pending_CallbackCalls;
200 CMOCK_MEM_INDEX_TYPE fwk_interrupt_clear_pending_CallInstance;
201 char fwk_interrupt_set_isr_IgnoreBool;
202 int fwk_interrupt_set_isr_FinalReturn;
203 char fwk_interrupt_set_isr_CallbackBool;
204 CMOCK_fwk_interrupt_set_isr_CALLBACK fwk_interrupt_set_isr_CallbackFunctionPointer;
205 int fwk_interrupt_set_isr_CallbackCalls;
206 CMOCK_MEM_INDEX_TYPE fwk_interrupt_set_isr_CallInstance;
207 char fwk_interrupt_set_isr_param_IgnoreBool;
208 int fwk_interrupt_set_isr_param_FinalReturn;
209 char fwk_interrupt_set_isr_param_CallbackBool;
210 CMOCK_fwk_interrupt_set_isr_param_CALLBACK fwk_interrupt_set_isr_param_CallbackFunctionPointer;
211 int fwk_interrupt_set_isr_param_CallbackCalls;
212 CMOCK_MEM_INDEX_TYPE fwk_interrupt_set_isr_param_CallInstance;
213 char fwk_interrupt_get_current_IgnoreBool;
214 int fwk_interrupt_get_current_FinalReturn;
215 char fwk_interrupt_get_current_CallbackBool;
216 CMOCK_fwk_interrupt_get_current_CALLBACK fwk_interrupt_get_current_CallbackFunctionPointer;
217 int fwk_interrupt_get_current_CallbackCalls;
218 CMOCK_MEM_INDEX_TYPE fwk_interrupt_get_current_CallInstance;
219 char fwk_is_interrupt_context_IgnoreBool;
220 bool fwk_is_interrupt_context_FinalReturn;
221 char fwk_is_interrupt_context_CallbackBool;
222 CMOCK_fwk_is_interrupt_context_CALLBACK fwk_is_interrupt_context_CallbackFunctionPointer;
223 int fwk_is_interrupt_context_CallbackCalls;
224 CMOCK_MEM_INDEX_TYPE fwk_is_interrupt_context_CallInstance;
225 } Mock;
226
227 extern jmp_buf AbortFrame;
228
Mockfwk_interrupt_Verify(void)229 void Mockfwk_interrupt_Verify(void)
230 {
231 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
232 CMOCK_MEM_INDEX_TYPE call_instance;
233 call_instance = Mock.fwk_interrupt_init_CallInstance;
234 if (Mock.fwk_interrupt_init_IgnoreBool)
235 call_instance = CMOCK_GUTS_NONE;
236 if (CMOCK_GUTS_NONE != call_instance)
237 {
238 UNITY_SET_DETAIL(CMockString_fwk_interrupt_init);
239 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
240 }
241 if (Mock.fwk_interrupt_init_CallbackFunctionPointer != NULL)
242 {
243 call_instance = CMOCK_GUTS_NONE;
244 (void)call_instance;
245 }
246 call_instance = Mock.fwk_interrupt_is_enabled_CallInstance;
247 if (Mock.fwk_interrupt_is_enabled_IgnoreBool)
248 call_instance = CMOCK_GUTS_NONE;
249 if (CMOCK_GUTS_NONE != call_instance)
250 {
251 UNITY_SET_DETAIL(CMockString_fwk_interrupt_is_enabled);
252 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
253 }
254 if (Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer != NULL)
255 {
256 call_instance = CMOCK_GUTS_NONE;
257 (void)call_instance;
258 }
259 call_instance = Mock.fwk_interrupt_enable_CallInstance;
260 if (Mock.fwk_interrupt_enable_IgnoreBool)
261 call_instance = CMOCK_GUTS_NONE;
262 if (CMOCK_GUTS_NONE != call_instance)
263 {
264 UNITY_SET_DETAIL(CMockString_fwk_interrupt_enable);
265 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
266 }
267 if (Mock.fwk_interrupt_enable_CallbackFunctionPointer != NULL)
268 {
269 call_instance = CMOCK_GUTS_NONE;
270 (void)call_instance;
271 }
272 call_instance = Mock.fwk_interrupt_disable_CallInstance;
273 if (Mock.fwk_interrupt_disable_IgnoreBool)
274 call_instance = CMOCK_GUTS_NONE;
275 if (CMOCK_GUTS_NONE != call_instance)
276 {
277 UNITY_SET_DETAIL(CMockString_fwk_interrupt_disable);
278 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
279 }
280 if (Mock.fwk_interrupt_disable_CallbackFunctionPointer != NULL)
281 {
282 call_instance = CMOCK_GUTS_NONE;
283 (void)call_instance;
284 }
285 call_instance = Mock.fwk_interrupt_is_pending_CallInstance;
286 if (Mock.fwk_interrupt_is_pending_IgnoreBool)
287 call_instance = CMOCK_GUTS_NONE;
288 if (CMOCK_GUTS_NONE != call_instance)
289 {
290 UNITY_SET_DETAIL(CMockString_fwk_interrupt_is_pending);
291 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
292 }
293 if (Mock.fwk_interrupt_is_pending_CallbackFunctionPointer != NULL)
294 {
295 call_instance = CMOCK_GUTS_NONE;
296 (void)call_instance;
297 }
298 call_instance = Mock.fwk_interrupt_set_pending_CallInstance;
299 if (Mock.fwk_interrupt_set_pending_IgnoreBool)
300 call_instance = CMOCK_GUTS_NONE;
301 if (CMOCK_GUTS_NONE != call_instance)
302 {
303 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_pending);
304 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
305 }
306 if (Mock.fwk_interrupt_set_pending_CallbackFunctionPointer != NULL)
307 {
308 call_instance = CMOCK_GUTS_NONE;
309 (void)call_instance;
310 }
311 call_instance = Mock.fwk_interrupt_clear_pending_CallInstance;
312 if (Mock.fwk_interrupt_clear_pending_IgnoreBool)
313 call_instance = CMOCK_GUTS_NONE;
314 if (CMOCK_GUTS_NONE != call_instance)
315 {
316 UNITY_SET_DETAIL(CMockString_fwk_interrupt_clear_pending);
317 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
318 }
319 if (Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer != NULL)
320 {
321 call_instance = CMOCK_GUTS_NONE;
322 (void)call_instance;
323 }
324 call_instance = Mock.fwk_interrupt_set_isr_CallInstance;
325 if (Mock.fwk_interrupt_set_isr_IgnoreBool)
326 call_instance = CMOCK_GUTS_NONE;
327 if (CMOCK_GUTS_NONE != call_instance)
328 {
329 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_isr);
330 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
331 }
332 if (Mock.fwk_interrupt_set_isr_CallbackFunctionPointer != NULL)
333 {
334 call_instance = CMOCK_GUTS_NONE;
335 (void)call_instance;
336 }
337 call_instance = Mock.fwk_interrupt_set_isr_param_CallInstance;
338 if (Mock.fwk_interrupt_set_isr_param_IgnoreBool)
339 call_instance = CMOCK_GUTS_NONE;
340 if (CMOCK_GUTS_NONE != call_instance)
341 {
342 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_isr_param);
343 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
344 }
345 if (Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer != NULL)
346 {
347 call_instance = CMOCK_GUTS_NONE;
348 (void)call_instance;
349 }
350 call_instance = Mock.fwk_interrupt_get_current_CallInstance;
351 if (Mock.fwk_interrupt_get_current_IgnoreBool)
352 call_instance = CMOCK_GUTS_NONE;
353 if (CMOCK_GUTS_NONE != call_instance)
354 {
355 UNITY_SET_DETAIL(CMockString_fwk_interrupt_get_current);
356 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
357 }
358 if (Mock.fwk_interrupt_get_current_CallbackFunctionPointer != NULL)
359 {
360 call_instance = CMOCK_GUTS_NONE;
361 (void)call_instance;
362 }
363 call_instance = Mock.fwk_is_interrupt_context_CallInstance;
364 if (Mock.fwk_is_interrupt_context_IgnoreBool)
365 call_instance = CMOCK_GUTS_NONE;
366 if (CMOCK_GUTS_NONE != call_instance)
367 {
368 UNITY_SET_DETAIL(CMockString_fwk_is_interrupt_context);
369 UNITY_TEST_FAIL(cmock_line, CMockStringCalledLess);
370 }
371 if (Mock.fwk_is_interrupt_context_CallbackFunctionPointer != NULL)
372 {
373 call_instance = CMOCK_GUTS_NONE;
374 (void)call_instance;
375 }
376 }
377
Mockfwk_interrupt_Init(void)378 void Mockfwk_interrupt_Init(void)
379 {
380 Mockfwk_interrupt_Destroy();
381 }
382
Mockfwk_interrupt_Destroy(void)383 void Mockfwk_interrupt_Destroy(void)
384 {
385 CMock_Guts_MemFreeAll();
386 memset(&Mock, 0, sizeof(Mock));
387 }
388
fwk_interrupt_init(const struct fwk_arch_interrupt_driver * driver)389 int fwk_interrupt_init(const struct fwk_arch_interrupt_driver* driver)
390 {
391 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
392 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance;
393 UNITY_SET_DETAIL(CMockString_fwk_interrupt_init);
394 cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_init_CallInstance);
395 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_init_CallInstance);
396 if (Mock.fwk_interrupt_init_IgnoreBool)
397 {
398 UNITY_CLR_DETAILS();
399 if (cmock_call_instance == NULL)
400 return Mock.fwk_interrupt_init_FinalReturn;
401 Mock.fwk_interrupt_init_FinalReturn = cmock_call_instance->ReturnVal;
402 return cmock_call_instance->ReturnVal;
403 }
404 if (!Mock.fwk_interrupt_init_CallbackBool &&
405 Mock.fwk_interrupt_init_CallbackFunctionPointer != NULL)
406 {
407 int cmock_cb_ret = Mock.fwk_interrupt_init_CallbackFunctionPointer(driver, Mock.fwk_interrupt_init_CallbackCalls++);
408 UNITY_CLR_DETAILS();
409 return cmock_cb_ret;
410 }
411 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
412 cmock_line = cmock_call_instance->LineNumber;
413 if (!cmock_call_instance->ExpectAnyArgsBool)
414 {
415 if (!cmock_call_instance->IgnoreArg_driver)
416 {
417 UNITY_SET_DETAILS(CMockString_fwk_interrupt_init,CMockString_driver);
418 if (cmock_call_instance->Expected_driver == NULL)
419 { UNITY_TEST_ASSERT_NULL(driver, cmock_line, CMockStringExpNULL); }
420 else
421 { UNITY_TEST_ASSERT_EQUAL_MEMORY_ARRAY((void*)(cmock_call_instance->Expected_driver), (void*)(driver), sizeof(const struct fwk_arch_interrupt_driver), cmock_call_instance->Expected_driver_Depth, cmock_line, CMockStringMismatch); }
422 }
423 }
424 if (Mock.fwk_interrupt_init_CallbackFunctionPointer != NULL)
425 {
426 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_init_CallbackFunctionPointer(driver, Mock.fwk_interrupt_init_CallbackCalls++);
427 }
428 UNITY_CLR_DETAILS();
429 return cmock_call_instance->ReturnVal;
430 }
431
432 void CMockExpectParameters_fwk_interrupt_init(CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance, const struct fwk_arch_interrupt_driver* driver, int driver_Depth);
CMockExpectParameters_fwk_interrupt_init(CMOCK_fwk_interrupt_init_CALL_INSTANCE * cmock_call_instance,const struct fwk_arch_interrupt_driver * driver,int driver_Depth)433 void CMockExpectParameters_fwk_interrupt_init(CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance, const struct fwk_arch_interrupt_driver* driver, int driver_Depth)
434 {
435 cmock_call_instance->Expected_driver = driver;
436 cmock_call_instance->Expected_driver_Depth = driver_Depth;
437 cmock_call_instance->IgnoreArg_driver = 0;
438 }
439
fwk_interrupt_init_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)440 void fwk_interrupt_init_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
441 {
442 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_init_CALL_INSTANCE));
443 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
444 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
445 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
446 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_init_CallInstance, cmock_guts_index);
447 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
448 cmock_call_instance->LineNumber = cmock_line;
449 cmock_call_instance->ExpectAnyArgsBool = (char)0;
450 cmock_call_instance->ReturnVal = cmock_to_return;
451 Mock.fwk_interrupt_init_IgnoreBool = (char)1;
452 }
453
fwk_interrupt_init_CMockStopIgnore(void)454 void fwk_interrupt_init_CMockStopIgnore(void)
455 {
456 if(Mock.fwk_interrupt_init_IgnoreBool)
457 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_init_CallInstance);
458 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
459 }
460
fwk_interrupt_init_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)461 void fwk_interrupt_init_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
462 {
463 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_init_CALL_INSTANCE));
464 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
465 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
466 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
467 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_init_CallInstance, cmock_guts_index);
468 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
469 cmock_call_instance->LineNumber = cmock_line;
470 cmock_call_instance->ExpectAnyArgsBool = (char)0;
471 cmock_call_instance->ReturnVal = cmock_to_return;
472 cmock_call_instance->ExpectAnyArgsBool = (char)1;
473 }
474
fwk_interrupt_init_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,const struct fwk_arch_interrupt_driver * driver,int cmock_to_return)475 void fwk_interrupt_init_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, const struct fwk_arch_interrupt_driver* driver, int cmock_to_return)
476 {
477 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_init_CALL_INSTANCE));
478 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
479 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
480 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
481 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_init_CallInstance, cmock_guts_index);
482 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
483 cmock_call_instance->LineNumber = cmock_line;
484 cmock_call_instance->ExpectAnyArgsBool = (char)0;
485 CMockExpectParameters_fwk_interrupt_init(cmock_call_instance, driver, 1);
486 cmock_call_instance->ReturnVal = cmock_to_return;
487 }
488
fwk_interrupt_init_AddCallback(CMOCK_fwk_interrupt_init_CALLBACK Callback)489 void fwk_interrupt_init_AddCallback(CMOCK_fwk_interrupt_init_CALLBACK Callback)
490 {
491 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
492 Mock.fwk_interrupt_init_CallbackBool = (char)1;
493 Mock.fwk_interrupt_init_CallbackFunctionPointer = Callback;
494 }
495
fwk_interrupt_init_Stub(CMOCK_fwk_interrupt_init_CALLBACK Callback)496 void fwk_interrupt_init_Stub(CMOCK_fwk_interrupt_init_CALLBACK Callback)
497 {
498 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
499 Mock.fwk_interrupt_init_CallbackBool = (char)0;
500 Mock.fwk_interrupt_init_CallbackFunctionPointer = Callback;
501 }
502
fwk_interrupt_init_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line,const struct fwk_arch_interrupt_driver * driver,int driver_Depth,int cmock_to_return)503 void fwk_interrupt_init_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, const struct fwk_arch_interrupt_driver* driver, int driver_Depth, int cmock_to_return)
504 {
505 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_init_CALL_INSTANCE));
506 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
507 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
508 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
509 Mock.fwk_interrupt_init_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_init_CallInstance, cmock_guts_index);
510 Mock.fwk_interrupt_init_IgnoreBool = (char)0;
511 cmock_call_instance->LineNumber = cmock_line;
512 cmock_call_instance->ExpectAnyArgsBool = (char)0;
513 CMockExpectParameters_fwk_interrupt_init(cmock_call_instance, driver, driver_Depth);
514 cmock_call_instance->ReturnVal = cmock_to_return;
515 }
516
fwk_interrupt_init_CMockIgnoreArg_driver(UNITY_LINE_TYPE cmock_line)517 void fwk_interrupt_init_CMockIgnoreArg_driver(UNITY_LINE_TYPE cmock_line)
518 {
519 CMOCK_fwk_interrupt_init_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_init_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_init_CallInstance));
520 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
521 cmock_call_instance->IgnoreArg_driver = 1;
522 }
523
fwk_interrupt_is_enabled(unsigned int interrupt,bool * enabled)524 int fwk_interrupt_is_enabled(unsigned int interrupt, bool* enabled)
525 {
526 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
527 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance;
528 UNITY_SET_DETAIL(CMockString_fwk_interrupt_is_enabled);
529 cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_is_enabled_CallInstance);
530 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_is_enabled_CallInstance);
531 if (Mock.fwk_interrupt_is_enabled_IgnoreBool)
532 {
533 UNITY_CLR_DETAILS();
534 if (cmock_call_instance == NULL)
535 return Mock.fwk_interrupt_is_enabled_FinalReturn;
536 Mock.fwk_interrupt_is_enabled_FinalReturn = cmock_call_instance->ReturnVal;
537 return cmock_call_instance->ReturnVal;
538 }
539 if (!Mock.fwk_interrupt_is_enabled_CallbackBool &&
540 Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer != NULL)
541 {
542 int cmock_cb_ret = Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer(interrupt, enabled, Mock.fwk_interrupt_is_enabled_CallbackCalls++);
543 UNITY_CLR_DETAILS();
544 return cmock_cb_ret;
545 }
546 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
547 cmock_line = cmock_call_instance->LineNumber;
548 if (!cmock_call_instance->ExpectAnyArgsBool)
549 {
550 if (!cmock_call_instance->IgnoreArg_interrupt)
551 {
552 UNITY_SET_DETAILS(CMockString_fwk_interrupt_is_enabled,CMockString_interrupt);
553 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
554 }
555 if (!cmock_call_instance->IgnoreArg_enabled)
556 {
557 UNITY_SET_DETAILS(CMockString_fwk_interrupt_is_enabled,CMockString_enabled);
558 if (cmock_call_instance->Expected_enabled == NULL)
559 { UNITY_TEST_ASSERT_NULL(enabled, cmock_line, CMockStringExpNULL); }
560 else
561 { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_enabled, enabled, cmock_call_instance->Expected_enabled_Depth, cmock_line, CMockStringMismatch); }
562 }
563 }
564 if (Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer != NULL)
565 {
566 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer(interrupt, enabled, Mock.fwk_interrupt_is_enabled_CallbackCalls++);
567 }
568 if (cmock_call_instance->ReturnThruPtr_enabled_Used)
569 {
570 UNITY_TEST_ASSERT_NOT_NULL(enabled, cmock_line, CMockStringPtrIsNULL);
571 memcpy((void*)enabled, (void*)cmock_call_instance->ReturnThruPtr_enabled_Val,
572 cmock_call_instance->ReturnThruPtr_enabled_Size);
573 }
574 UNITY_CLR_DETAILS();
575 return cmock_call_instance->ReturnVal;
576 }
577
578 void CMockExpectParameters_fwk_interrupt_is_enabled(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, bool* enabled, int enabled_Depth);
CMockExpectParameters_fwk_interrupt_is_enabled(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt,bool * enabled,int enabled_Depth)579 void CMockExpectParameters_fwk_interrupt_is_enabled(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, bool* enabled, int enabled_Depth)
580 {
581 cmock_call_instance->Expected_interrupt = interrupt;
582 cmock_call_instance->IgnoreArg_interrupt = 0;
583 cmock_call_instance->Expected_enabled = enabled;
584 cmock_call_instance->Expected_enabled_Depth = enabled_Depth;
585 cmock_call_instance->IgnoreArg_enabled = 0;
586 cmock_call_instance->ReturnThruPtr_enabled_Used = 0;
587 }
588
fwk_interrupt_is_enabled_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)589 void fwk_interrupt_is_enabled_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
590 {
591 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE));
592 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
593 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
594 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
595 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_enabled_CallInstance, cmock_guts_index);
596 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
597 cmock_call_instance->LineNumber = cmock_line;
598 cmock_call_instance->ExpectAnyArgsBool = (char)0;
599 cmock_call_instance->ReturnVal = cmock_to_return;
600 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)1;
601 }
602
fwk_interrupt_is_enabled_CMockStopIgnore(void)603 void fwk_interrupt_is_enabled_CMockStopIgnore(void)
604 {
605 if(Mock.fwk_interrupt_is_enabled_IgnoreBool)
606 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_is_enabled_CallInstance);
607 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
608 }
609
fwk_interrupt_is_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)610 void fwk_interrupt_is_enabled_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
611 {
612 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE));
613 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
614 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
615 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
616 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_enabled_CallInstance, cmock_guts_index);
617 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
618 cmock_call_instance->LineNumber = cmock_line;
619 cmock_call_instance->ExpectAnyArgsBool = (char)0;
620 cmock_call_instance->ReturnVal = cmock_to_return;
621 cmock_call_instance->ExpectAnyArgsBool = (char)1;
622 }
623
fwk_interrupt_is_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,bool * enabled,int cmock_to_return)624 void fwk_interrupt_is_enabled_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, bool* enabled, int cmock_to_return)
625 {
626 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE));
627 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
628 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
629 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
630 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_enabled_CallInstance, cmock_guts_index);
631 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
632 cmock_call_instance->LineNumber = cmock_line;
633 cmock_call_instance->ExpectAnyArgsBool = (char)0;
634 CMockExpectParameters_fwk_interrupt_is_enabled(cmock_call_instance, interrupt, enabled, 1);
635 cmock_call_instance->ReturnVal = cmock_to_return;
636 }
637
fwk_interrupt_is_enabled_AddCallback(CMOCK_fwk_interrupt_is_enabled_CALLBACK Callback)638 void fwk_interrupt_is_enabled_AddCallback(CMOCK_fwk_interrupt_is_enabled_CALLBACK Callback)
639 {
640 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
641 Mock.fwk_interrupt_is_enabled_CallbackBool = (char)1;
642 Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer = Callback;
643 }
644
fwk_interrupt_is_enabled_Stub(CMOCK_fwk_interrupt_is_enabled_CALLBACK Callback)645 void fwk_interrupt_is_enabled_Stub(CMOCK_fwk_interrupt_is_enabled_CALLBACK Callback)
646 {
647 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
648 Mock.fwk_interrupt_is_enabled_CallbackBool = (char)0;
649 Mock.fwk_interrupt_is_enabled_CallbackFunctionPointer = Callback;
650 }
651
fwk_interrupt_is_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,bool * enabled,int enabled_Depth,int cmock_to_return)652 void fwk_interrupt_is_enabled_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, bool* enabled, int enabled_Depth, int cmock_to_return)
653 {
654 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE));
655 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
656 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
657 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
658 Mock.fwk_interrupt_is_enabled_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_enabled_CallInstance, cmock_guts_index);
659 Mock.fwk_interrupt_is_enabled_IgnoreBool = (char)0;
660 cmock_call_instance->LineNumber = cmock_line;
661 cmock_call_instance->ExpectAnyArgsBool = (char)0;
662 CMockExpectParameters_fwk_interrupt_is_enabled(cmock_call_instance, interrupt, enabled, enabled_Depth);
663 cmock_call_instance->ReturnVal = cmock_to_return;
664 }
665
fwk_interrupt_is_enabled_CMockReturnMemThruPtr_enabled(UNITY_LINE_TYPE cmock_line,bool * enabled,size_t cmock_size)666 void fwk_interrupt_is_enabled_CMockReturnMemThruPtr_enabled(UNITY_LINE_TYPE cmock_line, bool* enabled, size_t cmock_size)
667 {
668 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_enabled_CallInstance));
669 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
670 cmock_call_instance->ReturnThruPtr_enabled_Used = 1;
671 cmock_call_instance->ReturnThruPtr_enabled_Val = enabled;
672 cmock_call_instance->ReturnThruPtr_enabled_Size = cmock_size;
673 }
674
fwk_interrupt_is_enabled_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)675 void fwk_interrupt_is_enabled_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
676 {
677 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_enabled_CallInstance));
678 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
679 cmock_call_instance->IgnoreArg_interrupt = 1;
680 }
681
fwk_interrupt_is_enabled_CMockIgnoreArg_enabled(UNITY_LINE_TYPE cmock_line)682 void fwk_interrupt_is_enabled_CMockIgnoreArg_enabled(UNITY_LINE_TYPE cmock_line)
683 {
684 CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_enabled_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_enabled_CallInstance));
685 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
686 cmock_call_instance->IgnoreArg_enabled = 1;
687 }
688
fwk_interrupt_enable(unsigned int interrupt)689 int fwk_interrupt_enable(unsigned int interrupt)
690 {
691 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
692 CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance;
693 UNITY_SET_DETAIL(CMockString_fwk_interrupt_enable);
694 cmock_call_instance = (CMOCK_fwk_interrupt_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_enable_CallInstance);
695 Mock.fwk_interrupt_enable_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_enable_CallInstance);
696 if (Mock.fwk_interrupt_enable_IgnoreBool)
697 {
698 UNITY_CLR_DETAILS();
699 if (cmock_call_instance == NULL)
700 return Mock.fwk_interrupt_enable_FinalReturn;
701 Mock.fwk_interrupt_enable_FinalReturn = cmock_call_instance->ReturnVal;
702 return cmock_call_instance->ReturnVal;
703 }
704 if (!Mock.fwk_interrupt_enable_CallbackBool &&
705 Mock.fwk_interrupt_enable_CallbackFunctionPointer != NULL)
706 {
707 int cmock_cb_ret = Mock.fwk_interrupt_enable_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_enable_CallbackCalls++);
708 UNITY_CLR_DETAILS();
709 return cmock_cb_ret;
710 }
711 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
712 cmock_line = cmock_call_instance->LineNumber;
713 if (!cmock_call_instance->ExpectAnyArgsBool)
714 {
715 if (!cmock_call_instance->IgnoreArg_interrupt)
716 {
717 UNITY_SET_DETAILS(CMockString_fwk_interrupt_enable,CMockString_interrupt);
718 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
719 }
720 }
721 if (Mock.fwk_interrupt_enable_CallbackFunctionPointer != NULL)
722 {
723 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_enable_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_enable_CallbackCalls++);
724 }
725 UNITY_CLR_DETAILS();
726 return cmock_call_instance->ReturnVal;
727 }
728
729 void CMockExpectParameters_fwk_interrupt_enable(CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt);
CMockExpectParameters_fwk_interrupt_enable(CMOCK_fwk_interrupt_enable_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt)730 void CMockExpectParameters_fwk_interrupt_enable(CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt)
731 {
732 cmock_call_instance->Expected_interrupt = interrupt;
733 cmock_call_instance->IgnoreArg_interrupt = 0;
734 }
735
fwk_interrupt_enable_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)736 void fwk_interrupt_enable_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
737 {
738 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_enable_CALL_INSTANCE));
739 CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
740 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
741 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
742 Mock.fwk_interrupt_enable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_enable_CallInstance, cmock_guts_index);
743 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
744 cmock_call_instance->LineNumber = cmock_line;
745 cmock_call_instance->ExpectAnyArgsBool = (char)0;
746 cmock_call_instance->ReturnVal = cmock_to_return;
747 Mock.fwk_interrupt_enable_IgnoreBool = (char)1;
748 }
749
fwk_interrupt_enable_CMockStopIgnore(void)750 void fwk_interrupt_enable_CMockStopIgnore(void)
751 {
752 if(Mock.fwk_interrupt_enable_IgnoreBool)
753 Mock.fwk_interrupt_enable_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_enable_CallInstance);
754 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
755 }
756
fwk_interrupt_enable_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)757 void fwk_interrupt_enable_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
758 {
759 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_enable_CALL_INSTANCE));
760 CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
761 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
762 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
763 Mock.fwk_interrupt_enable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_enable_CallInstance, cmock_guts_index);
764 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
765 cmock_call_instance->LineNumber = cmock_line;
766 cmock_call_instance->ExpectAnyArgsBool = (char)0;
767 cmock_call_instance->ReturnVal = cmock_to_return;
768 cmock_call_instance->ExpectAnyArgsBool = (char)1;
769 }
770
fwk_interrupt_enable_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,int cmock_to_return)771 void fwk_interrupt_enable_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, int cmock_to_return)
772 {
773 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_enable_CALL_INSTANCE));
774 CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
775 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
776 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
777 Mock.fwk_interrupt_enable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_enable_CallInstance, cmock_guts_index);
778 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
779 cmock_call_instance->LineNumber = cmock_line;
780 cmock_call_instance->ExpectAnyArgsBool = (char)0;
781 CMockExpectParameters_fwk_interrupt_enable(cmock_call_instance, interrupt);
782 cmock_call_instance->ReturnVal = cmock_to_return;
783 }
784
fwk_interrupt_enable_AddCallback(CMOCK_fwk_interrupt_enable_CALLBACK Callback)785 void fwk_interrupt_enable_AddCallback(CMOCK_fwk_interrupt_enable_CALLBACK Callback)
786 {
787 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
788 Mock.fwk_interrupt_enable_CallbackBool = (char)1;
789 Mock.fwk_interrupt_enable_CallbackFunctionPointer = Callback;
790 }
791
fwk_interrupt_enable_Stub(CMOCK_fwk_interrupt_enable_CALLBACK Callback)792 void fwk_interrupt_enable_Stub(CMOCK_fwk_interrupt_enable_CALLBACK Callback)
793 {
794 Mock.fwk_interrupt_enable_IgnoreBool = (char)0;
795 Mock.fwk_interrupt_enable_CallbackBool = (char)0;
796 Mock.fwk_interrupt_enable_CallbackFunctionPointer = Callback;
797 }
798
fwk_interrupt_enable_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)799 void fwk_interrupt_enable_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
800 {
801 CMOCK_fwk_interrupt_enable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_enable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_enable_CallInstance));
802 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
803 cmock_call_instance->IgnoreArg_interrupt = 1;
804 }
805
fwk_interrupt_disable(unsigned int interrupt)806 int fwk_interrupt_disable(unsigned int interrupt)
807 {
808 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
809 CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance;
810 UNITY_SET_DETAIL(CMockString_fwk_interrupt_disable);
811 cmock_call_instance = (CMOCK_fwk_interrupt_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_disable_CallInstance);
812 Mock.fwk_interrupt_disable_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_disable_CallInstance);
813 if (Mock.fwk_interrupt_disable_IgnoreBool)
814 {
815 UNITY_CLR_DETAILS();
816 if (cmock_call_instance == NULL)
817 return Mock.fwk_interrupt_disable_FinalReturn;
818 Mock.fwk_interrupt_disable_FinalReturn = cmock_call_instance->ReturnVal;
819 return cmock_call_instance->ReturnVal;
820 }
821 if (!Mock.fwk_interrupt_disable_CallbackBool &&
822 Mock.fwk_interrupt_disable_CallbackFunctionPointer != NULL)
823 {
824 int cmock_cb_ret = Mock.fwk_interrupt_disable_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_disable_CallbackCalls++);
825 UNITY_CLR_DETAILS();
826 return cmock_cb_ret;
827 }
828 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
829 cmock_line = cmock_call_instance->LineNumber;
830 if (!cmock_call_instance->ExpectAnyArgsBool)
831 {
832 if (!cmock_call_instance->IgnoreArg_interrupt)
833 {
834 UNITY_SET_DETAILS(CMockString_fwk_interrupt_disable,CMockString_interrupt);
835 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
836 }
837 }
838 if (Mock.fwk_interrupt_disable_CallbackFunctionPointer != NULL)
839 {
840 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_disable_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_disable_CallbackCalls++);
841 }
842 UNITY_CLR_DETAILS();
843 return cmock_call_instance->ReturnVal;
844 }
845
846 void CMockExpectParameters_fwk_interrupt_disable(CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt);
CMockExpectParameters_fwk_interrupt_disable(CMOCK_fwk_interrupt_disable_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt)847 void CMockExpectParameters_fwk_interrupt_disable(CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt)
848 {
849 cmock_call_instance->Expected_interrupt = interrupt;
850 cmock_call_instance->IgnoreArg_interrupt = 0;
851 }
852
fwk_interrupt_disable_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)853 void fwk_interrupt_disable_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
854 {
855 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_disable_CALL_INSTANCE));
856 CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
857 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
858 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
859 Mock.fwk_interrupt_disable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_disable_CallInstance, cmock_guts_index);
860 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
861 cmock_call_instance->LineNumber = cmock_line;
862 cmock_call_instance->ExpectAnyArgsBool = (char)0;
863 cmock_call_instance->ReturnVal = cmock_to_return;
864 Mock.fwk_interrupt_disable_IgnoreBool = (char)1;
865 }
866
fwk_interrupt_disable_CMockStopIgnore(void)867 void fwk_interrupt_disable_CMockStopIgnore(void)
868 {
869 if(Mock.fwk_interrupt_disable_IgnoreBool)
870 Mock.fwk_interrupt_disable_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_disable_CallInstance);
871 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
872 }
873
fwk_interrupt_disable_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)874 void fwk_interrupt_disable_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
875 {
876 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_disable_CALL_INSTANCE));
877 CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
878 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
879 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
880 Mock.fwk_interrupt_disable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_disable_CallInstance, cmock_guts_index);
881 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
882 cmock_call_instance->LineNumber = cmock_line;
883 cmock_call_instance->ExpectAnyArgsBool = (char)0;
884 cmock_call_instance->ReturnVal = cmock_to_return;
885 cmock_call_instance->ExpectAnyArgsBool = (char)1;
886 }
887
fwk_interrupt_disable_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,int cmock_to_return)888 void fwk_interrupt_disable_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, int cmock_to_return)
889 {
890 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_disable_CALL_INSTANCE));
891 CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
892 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
893 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
894 Mock.fwk_interrupt_disable_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_disable_CallInstance, cmock_guts_index);
895 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
896 cmock_call_instance->LineNumber = cmock_line;
897 cmock_call_instance->ExpectAnyArgsBool = (char)0;
898 CMockExpectParameters_fwk_interrupt_disable(cmock_call_instance, interrupt);
899 cmock_call_instance->ReturnVal = cmock_to_return;
900 }
901
fwk_interrupt_disable_AddCallback(CMOCK_fwk_interrupt_disable_CALLBACK Callback)902 void fwk_interrupt_disable_AddCallback(CMOCK_fwk_interrupt_disable_CALLBACK Callback)
903 {
904 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
905 Mock.fwk_interrupt_disable_CallbackBool = (char)1;
906 Mock.fwk_interrupt_disable_CallbackFunctionPointer = Callback;
907 }
908
fwk_interrupt_disable_Stub(CMOCK_fwk_interrupt_disable_CALLBACK Callback)909 void fwk_interrupt_disable_Stub(CMOCK_fwk_interrupt_disable_CALLBACK Callback)
910 {
911 Mock.fwk_interrupt_disable_IgnoreBool = (char)0;
912 Mock.fwk_interrupt_disable_CallbackBool = (char)0;
913 Mock.fwk_interrupt_disable_CallbackFunctionPointer = Callback;
914 }
915
fwk_interrupt_disable_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)916 void fwk_interrupt_disable_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
917 {
918 CMOCK_fwk_interrupt_disable_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_disable_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_disable_CallInstance));
919 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
920 cmock_call_instance->IgnoreArg_interrupt = 1;
921 }
922
fwk_interrupt_is_pending(unsigned int interrupt,bool * pending)923 int fwk_interrupt_is_pending(unsigned int interrupt, bool* pending)
924 {
925 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
926 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance;
927 UNITY_SET_DETAIL(CMockString_fwk_interrupt_is_pending);
928 cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_is_pending_CallInstance);
929 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_is_pending_CallInstance);
930 if (Mock.fwk_interrupt_is_pending_IgnoreBool)
931 {
932 UNITY_CLR_DETAILS();
933 if (cmock_call_instance == NULL)
934 return Mock.fwk_interrupt_is_pending_FinalReturn;
935 Mock.fwk_interrupt_is_pending_FinalReturn = cmock_call_instance->ReturnVal;
936 return cmock_call_instance->ReturnVal;
937 }
938 if (!Mock.fwk_interrupt_is_pending_CallbackBool &&
939 Mock.fwk_interrupt_is_pending_CallbackFunctionPointer != NULL)
940 {
941 int cmock_cb_ret = Mock.fwk_interrupt_is_pending_CallbackFunctionPointer(interrupt, pending, Mock.fwk_interrupt_is_pending_CallbackCalls++);
942 UNITY_CLR_DETAILS();
943 return cmock_cb_ret;
944 }
945 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
946 cmock_line = cmock_call_instance->LineNumber;
947 if (!cmock_call_instance->ExpectAnyArgsBool)
948 {
949 if (!cmock_call_instance->IgnoreArg_interrupt)
950 {
951 UNITY_SET_DETAILS(CMockString_fwk_interrupt_is_pending,CMockString_interrupt);
952 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
953 }
954 if (!cmock_call_instance->IgnoreArg_pending)
955 {
956 UNITY_SET_DETAILS(CMockString_fwk_interrupt_is_pending,CMockString_pending);
957 if (cmock_call_instance->Expected_pending == NULL)
958 { UNITY_TEST_ASSERT_NULL(pending, cmock_line, CMockStringExpNULL); }
959 else
960 { UNITY_TEST_ASSERT_EQUAL_INT_ARRAY(cmock_call_instance->Expected_pending, pending, cmock_call_instance->Expected_pending_Depth, cmock_line, CMockStringMismatch); }
961 }
962 }
963 if (Mock.fwk_interrupt_is_pending_CallbackFunctionPointer != NULL)
964 {
965 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_is_pending_CallbackFunctionPointer(interrupt, pending, Mock.fwk_interrupt_is_pending_CallbackCalls++);
966 }
967 if (cmock_call_instance->ReturnThruPtr_pending_Used)
968 {
969 UNITY_TEST_ASSERT_NOT_NULL(pending, cmock_line, CMockStringPtrIsNULL);
970 memcpy((void*)pending, (void*)cmock_call_instance->ReturnThruPtr_pending_Val,
971 cmock_call_instance->ReturnThruPtr_pending_Size);
972 }
973 UNITY_CLR_DETAILS();
974 return cmock_call_instance->ReturnVal;
975 }
976
977 void CMockExpectParameters_fwk_interrupt_is_pending(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, bool* pending, int pending_Depth);
CMockExpectParameters_fwk_interrupt_is_pending(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt,bool * pending,int pending_Depth)978 void CMockExpectParameters_fwk_interrupt_is_pending(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, bool* pending, int pending_Depth)
979 {
980 cmock_call_instance->Expected_interrupt = interrupt;
981 cmock_call_instance->IgnoreArg_interrupt = 0;
982 cmock_call_instance->Expected_pending = pending;
983 cmock_call_instance->Expected_pending_Depth = pending_Depth;
984 cmock_call_instance->IgnoreArg_pending = 0;
985 cmock_call_instance->ReturnThruPtr_pending_Used = 0;
986 }
987
fwk_interrupt_is_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)988 void fwk_interrupt_is_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
989 {
990 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE));
991 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
992 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
993 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
994 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_pending_CallInstance, cmock_guts_index);
995 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
996 cmock_call_instance->LineNumber = cmock_line;
997 cmock_call_instance->ExpectAnyArgsBool = (char)0;
998 cmock_call_instance->ReturnVal = cmock_to_return;
999 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)1;
1000 }
1001
fwk_interrupt_is_pending_CMockStopIgnore(void)1002 void fwk_interrupt_is_pending_CMockStopIgnore(void)
1003 {
1004 if(Mock.fwk_interrupt_is_pending_IgnoreBool)
1005 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_is_pending_CallInstance);
1006 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1007 }
1008
fwk_interrupt_is_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1009 void fwk_interrupt_is_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1010 {
1011 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE));
1012 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1013 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1014 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1015 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_pending_CallInstance, cmock_guts_index);
1016 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1017 cmock_call_instance->LineNumber = cmock_line;
1018 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1019 cmock_call_instance->ReturnVal = cmock_to_return;
1020 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1021 }
1022
fwk_interrupt_is_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,bool * pending,int cmock_to_return)1023 void fwk_interrupt_is_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, bool* pending, int cmock_to_return)
1024 {
1025 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE));
1026 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1027 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1028 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1029 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_pending_CallInstance, cmock_guts_index);
1030 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1031 cmock_call_instance->LineNumber = cmock_line;
1032 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1033 CMockExpectParameters_fwk_interrupt_is_pending(cmock_call_instance, interrupt, pending, 1);
1034 cmock_call_instance->ReturnVal = cmock_to_return;
1035 }
1036
fwk_interrupt_is_pending_AddCallback(CMOCK_fwk_interrupt_is_pending_CALLBACK Callback)1037 void fwk_interrupt_is_pending_AddCallback(CMOCK_fwk_interrupt_is_pending_CALLBACK Callback)
1038 {
1039 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1040 Mock.fwk_interrupt_is_pending_CallbackBool = (char)1;
1041 Mock.fwk_interrupt_is_pending_CallbackFunctionPointer = Callback;
1042 }
1043
fwk_interrupt_is_pending_Stub(CMOCK_fwk_interrupt_is_pending_CALLBACK Callback)1044 void fwk_interrupt_is_pending_Stub(CMOCK_fwk_interrupt_is_pending_CALLBACK Callback)
1045 {
1046 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1047 Mock.fwk_interrupt_is_pending_CallbackBool = (char)0;
1048 Mock.fwk_interrupt_is_pending_CallbackFunctionPointer = Callback;
1049 }
1050
fwk_interrupt_is_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,bool * pending,int pending_Depth,int cmock_to_return)1051 void fwk_interrupt_is_pending_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, bool* pending, int pending_Depth, int cmock_to_return)
1052 {
1053 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE));
1054 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1055 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1056 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1057 Mock.fwk_interrupt_is_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_is_pending_CallInstance, cmock_guts_index);
1058 Mock.fwk_interrupt_is_pending_IgnoreBool = (char)0;
1059 cmock_call_instance->LineNumber = cmock_line;
1060 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1061 CMockExpectParameters_fwk_interrupt_is_pending(cmock_call_instance, interrupt, pending, pending_Depth);
1062 cmock_call_instance->ReturnVal = cmock_to_return;
1063 }
1064
fwk_interrupt_is_pending_CMockReturnMemThruPtr_pending(UNITY_LINE_TYPE cmock_line,bool * pending,size_t cmock_size)1065 void fwk_interrupt_is_pending_CMockReturnMemThruPtr_pending(UNITY_LINE_TYPE cmock_line, bool* pending, size_t cmock_size)
1066 {
1067 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_pending_CallInstance));
1068 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
1069 cmock_call_instance->ReturnThruPtr_pending_Used = 1;
1070 cmock_call_instance->ReturnThruPtr_pending_Val = pending;
1071 cmock_call_instance->ReturnThruPtr_pending_Size = cmock_size;
1072 }
1073
fwk_interrupt_is_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1074 void fwk_interrupt_is_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1075 {
1076 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_pending_CallInstance));
1077 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1078 cmock_call_instance->IgnoreArg_interrupt = 1;
1079 }
1080
fwk_interrupt_is_pending_CMockIgnoreArg_pending(UNITY_LINE_TYPE cmock_line)1081 void fwk_interrupt_is_pending_CMockIgnoreArg_pending(UNITY_LINE_TYPE cmock_line)
1082 {
1083 CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_is_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_is_pending_CallInstance));
1084 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1085 cmock_call_instance->IgnoreArg_pending = 1;
1086 }
1087
fwk_interrupt_set_pending(unsigned int interrupt)1088 int fwk_interrupt_set_pending(unsigned int interrupt)
1089 {
1090 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1091 CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance;
1092 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_pending);
1093 cmock_call_instance = (CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_set_pending_CallInstance);
1094 Mock.fwk_interrupt_set_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_pending_CallInstance);
1095 if (Mock.fwk_interrupt_set_pending_IgnoreBool)
1096 {
1097 UNITY_CLR_DETAILS();
1098 if (cmock_call_instance == NULL)
1099 return Mock.fwk_interrupt_set_pending_FinalReturn;
1100 Mock.fwk_interrupt_set_pending_FinalReturn = cmock_call_instance->ReturnVal;
1101 return cmock_call_instance->ReturnVal;
1102 }
1103 if (!Mock.fwk_interrupt_set_pending_CallbackBool &&
1104 Mock.fwk_interrupt_set_pending_CallbackFunctionPointer != NULL)
1105 {
1106 int cmock_cb_ret = Mock.fwk_interrupt_set_pending_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_set_pending_CallbackCalls++);
1107 UNITY_CLR_DETAILS();
1108 return cmock_cb_ret;
1109 }
1110 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1111 cmock_line = cmock_call_instance->LineNumber;
1112 if (!cmock_call_instance->ExpectAnyArgsBool)
1113 {
1114 if (!cmock_call_instance->IgnoreArg_interrupt)
1115 {
1116 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_pending,CMockString_interrupt);
1117 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
1118 }
1119 }
1120 if (Mock.fwk_interrupt_set_pending_CallbackFunctionPointer != NULL)
1121 {
1122 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_set_pending_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_set_pending_CallbackCalls++);
1123 }
1124 UNITY_CLR_DETAILS();
1125 return cmock_call_instance->ReturnVal;
1126 }
1127
1128 void CMockExpectParameters_fwk_interrupt_set_pending(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt);
CMockExpectParameters_fwk_interrupt_set_pending(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt)1129 void CMockExpectParameters_fwk_interrupt_set_pending(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt)
1130 {
1131 cmock_call_instance->Expected_interrupt = interrupt;
1132 cmock_call_instance->IgnoreArg_interrupt = 0;
1133 }
1134
fwk_interrupt_set_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1135 void fwk_interrupt_set_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1136 {
1137 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE));
1138 CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1139 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1140 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1141 Mock.fwk_interrupt_set_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_pending_CallInstance, cmock_guts_index);
1142 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1143 cmock_call_instance->LineNumber = cmock_line;
1144 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1145 cmock_call_instance->ReturnVal = cmock_to_return;
1146 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)1;
1147 }
1148
fwk_interrupt_set_pending_CMockStopIgnore(void)1149 void fwk_interrupt_set_pending_CMockStopIgnore(void)
1150 {
1151 if(Mock.fwk_interrupt_set_pending_IgnoreBool)
1152 Mock.fwk_interrupt_set_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_pending_CallInstance);
1153 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1154 }
1155
fwk_interrupt_set_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1156 void fwk_interrupt_set_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1157 {
1158 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE));
1159 CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1160 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1161 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1162 Mock.fwk_interrupt_set_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_pending_CallInstance, cmock_guts_index);
1163 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1164 cmock_call_instance->LineNumber = cmock_line;
1165 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1166 cmock_call_instance->ReturnVal = cmock_to_return;
1167 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1168 }
1169
fwk_interrupt_set_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,int cmock_to_return)1170 void fwk_interrupt_set_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, int cmock_to_return)
1171 {
1172 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE));
1173 CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1174 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1175 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1176 Mock.fwk_interrupt_set_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_pending_CallInstance, cmock_guts_index);
1177 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1178 cmock_call_instance->LineNumber = cmock_line;
1179 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1180 CMockExpectParameters_fwk_interrupt_set_pending(cmock_call_instance, interrupt);
1181 cmock_call_instance->ReturnVal = cmock_to_return;
1182 }
1183
fwk_interrupt_set_pending_AddCallback(CMOCK_fwk_interrupt_set_pending_CALLBACK Callback)1184 void fwk_interrupt_set_pending_AddCallback(CMOCK_fwk_interrupt_set_pending_CALLBACK Callback)
1185 {
1186 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1187 Mock.fwk_interrupt_set_pending_CallbackBool = (char)1;
1188 Mock.fwk_interrupt_set_pending_CallbackFunctionPointer = Callback;
1189 }
1190
fwk_interrupt_set_pending_Stub(CMOCK_fwk_interrupt_set_pending_CALLBACK Callback)1191 void fwk_interrupt_set_pending_Stub(CMOCK_fwk_interrupt_set_pending_CALLBACK Callback)
1192 {
1193 Mock.fwk_interrupt_set_pending_IgnoreBool = (char)0;
1194 Mock.fwk_interrupt_set_pending_CallbackBool = (char)0;
1195 Mock.fwk_interrupt_set_pending_CallbackFunctionPointer = Callback;
1196 }
1197
fwk_interrupt_set_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1198 void fwk_interrupt_set_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1199 {
1200 CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_pending_CallInstance));
1201 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1202 cmock_call_instance->IgnoreArg_interrupt = 1;
1203 }
1204
fwk_interrupt_clear_pending(unsigned int interrupt)1205 int fwk_interrupt_clear_pending(unsigned int interrupt)
1206 {
1207 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1208 CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance;
1209 UNITY_SET_DETAIL(CMockString_fwk_interrupt_clear_pending);
1210 cmock_call_instance = (CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_clear_pending_CallInstance);
1211 Mock.fwk_interrupt_clear_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_clear_pending_CallInstance);
1212 if (Mock.fwk_interrupt_clear_pending_IgnoreBool)
1213 {
1214 UNITY_CLR_DETAILS();
1215 if (cmock_call_instance == NULL)
1216 return Mock.fwk_interrupt_clear_pending_FinalReturn;
1217 Mock.fwk_interrupt_clear_pending_FinalReturn = cmock_call_instance->ReturnVal;
1218 return cmock_call_instance->ReturnVal;
1219 }
1220 if (!Mock.fwk_interrupt_clear_pending_CallbackBool &&
1221 Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer != NULL)
1222 {
1223 int cmock_cb_ret = Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_clear_pending_CallbackCalls++);
1224 UNITY_CLR_DETAILS();
1225 return cmock_cb_ret;
1226 }
1227 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1228 cmock_line = cmock_call_instance->LineNumber;
1229 if (!cmock_call_instance->ExpectAnyArgsBool)
1230 {
1231 if (!cmock_call_instance->IgnoreArg_interrupt)
1232 {
1233 UNITY_SET_DETAILS(CMockString_fwk_interrupt_clear_pending,CMockString_interrupt);
1234 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
1235 }
1236 }
1237 if (Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer != NULL)
1238 {
1239 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_clear_pending_CallbackCalls++);
1240 }
1241 UNITY_CLR_DETAILS();
1242 return cmock_call_instance->ReturnVal;
1243 }
1244
1245 void CMockExpectParameters_fwk_interrupt_clear_pending(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt);
CMockExpectParameters_fwk_interrupt_clear_pending(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt)1246 void CMockExpectParameters_fwk_interrupt_clear_pending(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt)
1247 {
1248 cmock_call_instance->Expected_interrupt = interrupt;
1249 cmock_call_instance->IgnoreArg_interrupt = 0;
1250 }
1251
fwk_interrupt_clear_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1252 void fwk_interrupt_clear_pending_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1253 {
1254 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE));
1255 CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1256 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1257 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1258 Mock.fwk_interrupt_clear_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_clear_pending_CallInstance, cmock_guts_index);
1259 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1260 cmock_call_instance->LineNumber = cmock_line;
1261 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1262 cmock_call_instance->ReturnVal = cmock_to_return;
1263 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)1;
1264 }
1265
fwk_interrupt_clear_pending_CMockStopIgnore(void)1266 void fwk_interrupt_clear_pending_CMockStopIgnore(void)
1267 {
1268 if(Mock.fwk_interrupt_clear_pending_IgnoreBool)
1269 Mock.fwk_interrupt_clear_pending_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_clear_pending_CallInstance);
1270 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1271 }
1272
fwk_interrupt_clear_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1273 void fwk_interrupt_clear_pending_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1274 {
1275 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE));
1276 CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1277 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1278 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1279 Mock.fwk_interrupt_clear_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_clear_pending_CallInstance, cmock_guts_index);
1280 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1281 cmock_call_instance->LineNumber = cmock_line;
1282 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1283 cmock_call_instance->ReturnVal = cmock_to_return;
1284 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1285 }
1286
fwk_interrupt_clear_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,int cmock_to_return)1287 void fwk_interrupt_clear_pending_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, int cmock_to_return)
1288 {
1289 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE));
1290 CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1291 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1292 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1293 Mock.fwk_interrupt_clear_pending_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_clear_pending_CallInstance, cmock_guts_index);
1294 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1295 cmock_call_instance->LineNumber = cmock_line;
1296 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1297 CMockExpectParameters_fwk_interrupt_clear_pending(cmock_call_instance, interrupt);
1298 cmock_call_instance->ReturnVal = cmock_to_return;
1299 }
1300
fwk_interrupt_clear_pending_AddCallback(CMOCK_fwk_interrupt_clear_pending_CALLBACK Callback)1301 void fwk_interrupt_clear_pending_AddCallback(CMOCK_fwk_interrupt_clear_pending_CALLBACK Callback)
1302 {
1303 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1304 Mock.fwk_interrupt_clear_pending_CallbackBool = (char)1;
1305 Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer = Callback;
1306 }
1307
fwk_interrupt_clear_pending_Stub(CMOCK_fwk_interrupt_clear_pending_CALLBACK Callback)1308 void fwk_interrupt_clear_pending_Stub(CMOCK_fwk_interrupt_clear_pending_CALLBACK Callback)
1309 {
1310 Mock.fwk_interrupt_clear_pending_IgnoreBool = (char)0;
1311 Mock.fwk_interrupt_clear_pending_CallbackBool = (char)0;
1312 Mock.fwk_interrupt_clear_pending_CallbackFunctionPointer = Callback;
1313 }
1314
fwk_interrupt_clear_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1315 void fwk_interrupt_clear_pending_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1316 {
1317 CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_clear_pending_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_clear_pending_CallInstance));
1318 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1319 cmock_call_instance->IgnoreArg_interrupt = 1;
1320 }
1321
fwk_interrupt_set_isr(unsigned int interrupt,cmock_fwk_interrupt_func_ptr1 isr)1322 int fwk_interrupt_set_isr(unsigned int interrupt, cmock_fwk_interrupt_func_ptr1 isr)
1323 {
1324 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1325 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance;
1326 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_isr);
1327 cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_set_isr_CallInstance);
1328 Mock.fwk_interrupt_set_isr_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_isr_CallInstance);
1329 if (Mock.fwk_interrupt_set_isr_IgnoreBool)
1330 {
1331 UNITY_CLR_DETAILS();
1332 if (cmock_call_instance == NULL)
1333 return Mock.fwk_interrupt_set_isr_FinalReturn;
1334 Mock.fwk_interrupt_set_isr_FinalReturn = cmock_call_instance->ReturnVal;
1335 return cmock_call_instance->ReturnVal;
1336 }
1337 if (!Mock.fwk_interrupt_set_isr_CallbackBool &&
1338 Mock.fwk_interrupt_set_isr_CallbackFunctionPointer != NULL)
1339 {
1340 int cmock_cb_ret = Mock.fwk_interrupt_set_isr_CallbackFunctionPointer(interrupt, isr, Mock.fwk_interrupt_set_isr_CallbackCalls++);
1341 UNITY_CLR_DETAILS();
1342 return cmock_cb_ret;
1343 }
1344 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1345 cmock_line = cmock_call_instance->LineNumber;
1346 if (!cmock_call_instance->ExpectAnyArgsBool)
1347 {
1348 if (!cmock_call_instance->IgnoreArg_interrupt)
1349 {
1350 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_isr,CMockString_interrupt);
1351 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
1352 }
1353 if (!cmock_call_instance->IgnoreArg_isr)
1354 {
1355 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_isr,CMockString_isr);
1356 UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_isr, isr, cmock_line, CMockStringMismatch);
1357 }
1358 }
1359 if (Mock.fwk_interrupt_set_isr_CallbackFunctionPointer != NULL)
1360 {
1361 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_set_isr_CallbackFunctionPointer(interrupt, isr, Mock.fwk_interrupt_set_isr_CallbackCalls++);
1362 }
1363 UNITY_CLR_DETAILS();
1364 return cmock_call_instance->ReturnVal;
1365 }
1366
1367 void CMockExpectParameters_fwk_interrupt_set_isr(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, cmock_fwk_interrupt_func_ptr1 isr);
CMockExpectParameters_fwk_interrupt_set_isr(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt,cmock_fwk_interrupt_func_ptr1 isr)1368 void CMockExpectParameters_fwk_interrupt_set_isr(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, cmock_fwk_interrupt_func_ptr1 isr)
1369 {
1370 cmock_call_instance->Expected_interrupt = interrupt;
1371 cmock_call_instance->IgnoreArg_interrupt = 0;
1372 memcpy((void*)(&cmock_call_instance->Expected_isr), (void*)(&isr),
1373 sizeof(cmock_fwk_interrupt_func_ptr1[sizeof(isr) == sizeof(cmock_fwk_interrupt_func_ptr1) ? 1 : -1])); /* add cmock_fwk_interrupt_func_ptr1 to :treat_as_array if this causes an error */
1374 cmock_call_instance->IgnoreArg_isr = 0;
1375 }
1376
fwk_interrupt_set_isr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1377 void fwk_interrupt_set_isr_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1378 {
1379 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE));
1380 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1381 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1382 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1383 Mock.fwk_interrupt_set_isr_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_CallInstance, cmock_guts_index);
1384 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1385 cmock_call_instance->LineNumber = cmock_line;
1386 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1387 cmock_call_instance->ReturnVal = cmock_to_return;
1388 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)1;
1389 }
1390
fwk_interrupt_set_isr_CMockStopIgnore(void)1391 void fwk_interrupt_set_isr_CMockStopIgnore(void)
1392 {
1393 if(Mock.fwk_interrupt_set_isr_IgnoreBool)
1394 Mock.fwk_interrupt_set_isr_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_isr_CallInstance);
1395 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1396 }
1397
fwk_interrupt_set_isr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1398 void fwk_interrupt_set_isr_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1399 {
1400 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE));
1401 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1402 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1403 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1404 Mock.fwk_interrupt_set_isr_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_CallInstance, cmock_guts_index);
1405 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1406 cmock_call_instance->LineNumber = cmock_line;
1407 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1408 cmock_call_instance->ReturnVal = cmock_to_return;
1409 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1410 }
1411
fwk_interrupt_set_isr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,cmock_fwk_interrupt_func_ptr1 isr,int cmock_to_return)1412 void fwk_interrupt_set_isr_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, cmock_fwk_interrupt_func_ptr1 isr, int cmock_to_return)
1413 {
1414 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE));
1415 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1416 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1417 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1418 Mock.fwk_interrupt_set_isr_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_CallInstance, cmock_guts_index);
1419 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1420 cmock_call_instance->LineNumber = cmock_line;
1421 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1422 CMockExpectParameters_fwk_interrupt_set_isr(cmock_call_instance, interrupt, isr);
1423 cmock_call_instance->ReturnVal = cmock_to_return;
1424 }
1425
fwk_interrupt_set_isr_AddCallback(CMOCK_fwk_interrupt_set_isr_CALLBACK Callback)1426 void fwk_interrupt_set_isr_AddCallback(CMOCK_fwk_interrupt_set_isr_CALLBACK Callback)
1427 {
1428 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1429 Mock.fwk_interrupt_set_isr_CallbackBool = (char)1;
1430 Mock.fwk_interrupt_set_isr_CallbackFunctionPointer = Callback;
1431 }
1432
fwk_interrupt_set_isr_Stub(CMOCK_fwk_interrupt_set_isr_CALLBACK Callback)1433 void fwk_interrupt_set_isr_Stub(CMOCK_fwk_interrupt_set_isr_CALLBACK Callback)
1434 {
1435 Mock.fwk_interrupt_set_isr_IgnoreBool = (char)0;
1436 Mock.fwk_interrupt_set_isr_CallbackBool = (char)0;
1437 Mock.fwk_interrupt_set_isr_CallbackFunctionPointer = Callback;
1438 }
1439
fwk_interrupt_set_isr_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1440 void fwk_interrupt_set_isr_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1441 {
1442 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_isr_CallInstance));
1443 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1444 cmock_call_instance->IgnoreArg_interrupt = 1;
1445 }
1446
fwk_interrupt_set_isr_CMockIgnoreArg_isr(UNITY_LINE_TYPE cmock_line)1447 void fwk_interrupt_set_isr_CMockIgnoreArg_isr(UNITY_LINE_TYPE cmock_line)
1448 {
1449 CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_isr_CallInstance));
1450 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1451 cmock_call_instance->IgnoreArg_isr = 1;
1452 }
1453
fwk_interrupt_set_isr_param(unsigned int interrupt,cmock_fwk_interrupt_func_ptr2 isr,uintptr_t param)1454 int fwk_interrupt_set_isr_param(unsigned int interrupt, cmock_fwk_interrupt_func_ptr2 isr, uintptr_t param)
1455 {
1456 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1457 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance;
1458 UNITY_SET_DETAIL(CMockString_fwk_interrupt_set_isr_param);
1459 cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_set_isr_param_CallInstance);
1460 Mock.fwk_interrupt_set_isr_param_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_isr_param_CallInstance);
1461 if (Mock.fwk_interrupt_set_isr_param_IgnoreBool)
1462 {
1463 UNITY_CLR_DETAILS();
1464 if (cmock_call_instance == NULL)
1465 return Mock.fwk_interrupt_set_isr_param_FinalReturn;
1466 Mock.fwk_interrupt_set_isr_param_FinalReturn = cmock_call_instance->ReturnVal;
1467 return cmock_call_instance->ReturnVal;
1468 }
1469 if (!Mock.fwk_interrupt_set_isr_param_CallbackBool &&
1470 Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer != NULL)
1471 {
1472 int cmock_cb_ret = Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer(interrupt, isr, param, Mock.fwk_interrupt_set_isr_param_CallbackCalls++);
1473 UNITY_CLR_DETAILS();
1474 return cmock_cb_ret;
1475 }
1476 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1477 cmock_line = cmock_call_instance->LineNumber;
1478 if (!cmock_call_instance->ExpectAnyArgsBool)
1479 {
1480 if (!cmock_call_instance->IgnoreArg_interrupt)
1481 {
1482 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_isr_param,CMockString_interrupt);
1483 UNITY_TEST_ASSERT_EQUAL_HEX32(cmock_call_instance->Expected_interrupt, interrupt, cmock_line, CMockStringMismatch);
1484 }
1485 if (!cmock_call_instance->IgnoreArg_isr)
1486 {
1487 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_isr_param,CMockString_isr);
1488 UNITY_TEST_ASSERT_EQUAL_PTR(cmock_call_instance->Expected_isr, isr, cmock_line, CMockStringMismatch);
1489 }
1490 if (!cmock_call_instance->IgnoreArg_param)
1491 {
1492 UNITY_SET_DETAILS(CMockString_fwk_interrupt_set_isr_param,CMockString_param);
1493 UNITY_TEST_ASSERT_EQUAL_MEMORY((void*)(&cmock_call_instance->Expected_param), (void*)(¶m), sizeof(uintptr_t), cmock_line, CMockStringMismatch);
1494 }
1495 }
1496 if (Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer != NULL)
1497 {
1498 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer(interrupt, isr, param, Mock.fwk_interrupt_set_isr_param_CallbackCalls++);
1499 }
1500 UNITY_CLR_DETAILS();
1501 return cmock_call_instance->ReturnVal;
1502 }
1503
1504 void CMockExpectParameters_fwk_interrupt_set_isr_param(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, cmock_fwk_interrupt_func_ptr2 isr, uintptr_t param);
CMockExpectParameters_fwk_interrupt_set_isr_param(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE * cmock_call_instance,unsigned int interrupt,cmock_fwk_interrupt_func_ptr2 isr,uintptr_t param)1505 void CMockExpectParameters_fwk_interrupt_set_isr_param(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance, unsigned int interrupt, cmock_fwk_interrupt_func_ptr2 isr, uintptr_t param)
1506 {
1507 cmock_call_instance->Expected_interrupt = interrupt;
1508 cmock_call_instance->IgnoreArg_interrupt = 0;
1509 memcpy((void*)(&cmock_call_instance->Expected_isr), (void*)(&isr),
1510 sizeof(cmock_fwk_interrupt_func_ptr2[sizeof(isr) == sizeof(cmock_fwk_interrupt_func_ptr2) ? 1 : -1])); /* add cmock_fwk_interrupt_func_ptr2 to :treat_as_array if this causes an error */
1511 cmock_call_instance->IgnoreArg_isr = 0;
1512 memcpy((void*)(&cmock_call_instance->Expected_param), (void*)(¶m),
1513 sizeof(uintptr_t[sizeof(param) == sizeof(uintptr_t) ? 1 : -1])); /* add uintptr_t to :treat_as_array if this causes an error */
1514 cmock_call_instance->IgnoreArg_param = 0;
1515 }
1516
fwk_interrupt_set_isr_param_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1517 void fwk_interrupt_set_isr_param_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1518 {
1519 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE));
1520 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1521 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1522 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1523 Mock.fwk_interrupt_set_isr_param_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_param_CallInstance, cmock_guts_index);
1524 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1525 cmock_call_instance->LineNumber = cmock_line;
1526 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1527 cmock_call_instance->ReturnVal = cmock_to_return;
1528 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)1;
1529 }
1530
fwk_interrupt_set_isr_param_CMockStopIgnore(void)1531 void fwk_interrupt_set_isr_param_CMockStopIgnore(void)
1532 {
1533 if(Mock.fwk_interrupt_set_isr_param_IgnoreBool)
1534 Mock.fwk_interrupt_set_isr_param_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_set_isr_param_CallInstance);
1535 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1536 }
1537
fwk_interrupt_set_isr_param_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1538 void fwk_interrupt_set_isr_param_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1539 {
1540 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE));
1541 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1542 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1543 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1544 Mock.fwk_interrupt_set_isr_param_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_param_CallInstance, cmock_guts_index);
1545 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1546 cmock_call_instance->LineNumber = cmock_line;
1547 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1548 cmock_call_instance->ReturnVal = cmock_to_return;
1549 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1550 }
1551
fwk_interrupt_set_isr_param_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int interrupt,cmock_fwk_interrupt_func_ptr2 isr,uintptr_t param,int cmock_to_return)1552 void fwk_interrupt_set_isr_param_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int interrupt, cmock_fwk_interrupt_func_ptr2 isr, uintptr_t param, int cmock_to_return)
1553 {
1554 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE));
1555 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1556 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1557 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1558 Mock.fwk_interrupt_set_isr_param_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_set_isr_param_CallInstance, cmock_guts_index);
1559 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1560 cmock_call_instance->LineNumber = cmock_line;
1561 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1562 CMockExpectParameters_fwk_interrupt_set_isr_param(cmock_call_instance, interrupt, isr, param);
1563 cmock_call_instance->ReturnVal = cmock_to_return;
1564 }
1565
fwk_interrupt_set_isr_param_AddCallback(CMOCK_fwk_interrupt_set_isr_param_CALLBACK Callback)1566 void fwk_interrupt_set_isr_param_AddCallback(CMOCK_fwk_interrupt_set_isr_param_CALLBACK Callback)
1567 {
1568 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1569 Mock.fwk_interrupt_set_isr_param_CallbackBool = (char)1;
1570 Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer = Callback;
1571 }
1572
fwk_interrupt_set_isr_param_Stub(CMOCK_fwk_interrupt_set_isr_param_CALLBACK Callback)1573 void fwk_interrupt_set_isr_param_Stub(CMOCK_fwk_interrupt_set_isr_param_CALLBACK Callback)
1574 {
1575 Mock.fwk_interrupt_set_isr_param_IgnoreBool = (char)0;
1576 Mock.fwk_interrupt_set_isr_param_CallbackBool = (char)0;
1577 Mock.fwk_interrupt_set_isr_param_CallbackFunctionPointer = Callback;
1578 }
1579
fwk_interrupt_set_isr_param_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1580 void fwk_interrupt_set_isr_param_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1581 {
1582 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_isr_param_CallInstance));
1583 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1584 cmock_call_instance->IgnoreArg_interrupt = 1;
1585 }
1586
fwk_interrupt_set_isr_param_CMockIgnoreArg_isr(UNITY_LINE_TYPE cmock_line)1587 void fwk_interrupt_set_isr_param_CMockIgnoreArg_isr(UNITY_LINE_TYPE cmock_line)
1588 {
1589 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_isr_param_CallInstance));
1590 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1591 cmock_call_instance->IgnoreArg_isr = 1;
1592 }
1593
fwk_interrupt_set_isr_param_CMockIgnoreArg_param(UNITY_LINE_TYPE cmock_line)1594 void fwk_interrupt_set_isr_param_CMockIgnoreArg_param(UNITY_LINE_TYPE cmock_line)
1595 {
1596 CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_set_isr_param_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_set_isr_param_CallInstance));
1597 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1598 cmock_call_instance->IgnoreArg_param = 1;
1599 }
1600
fwk_interrupt_get_current(unsigned int * interrupt)1601 int fwk_interrupt_get_current(unsigned int* interrupt)
1602 {
1603 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1604 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance;
1605 UNITY_SET_DETAIL(CMockString_fwk_interrupt_get_current);
1606 cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_interrupt_get_current_CallInstance);
1607 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_get_current_CallInstance);
1608 if (Mock.fwk_interrupt_get_current_IgnoreBool)
1609 {
1610 UNITY_CLR_DETAILS();
1611 if (cmock_call_instance == NULL)
1612 return Mock.fwk_interrupt_get_current_FinalReturn;
1613 Mock.fwk_interrupt_get_current_FinalReturn = cmock_call_instance->ReturnVal;
1614 return cmock_call_instance->ReturnVal;
1615 }
1616 if (!Mock.fwk_interrupt_get_current_CallbackBool &&
1617 Mock.fwk_interrupt_get_current_CallbackFunctionPointer != NULL)
1618 {
1619 int cmock_cb_ret = Mock.fwk_interrupt_get_current_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_get_current_CallbackCalls++);
1620 UNITY_CLR_DETAILS();
1621 return cmock_cb_ret;
1622 }
1623 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1624 cmock_line = cmock_call_instance->LineNumber;
1625 if (!cmock_call_instance->ExpectAnyArgsBool)
1626 {
1627 if (!cmock_call_instance->IgnoreArg_interrupt)
1628 {
1629 UNITY_SET_DETAILS(CMockString_fwk_interrupt_get_current,CMockString_interrupt);
1630 if (cmock_call_instance->Expected_interrupt == NULL)
1631 { UNITY_TEST_ASSERT_NULL(interrupt, cmock_line, CMockStringExpNULL); }
1632 else
1633 { UNITY_TEST_ASSERT_EQUAL_HEX32_ARRAY(cmock_call_instance->Expected_interrupt, interrupt, cmock_call_instance->Expected_interrupt_Depth, cmock_line, CMockStringMismatch); }
1634 }
1635 }
1636 if (Mock.fwk_interrupt_get_current_CallbackFunctionPointer != NULL)
1637 {
1638 cmock_call_instance->ReturnVal = Mock.fwk_interrupt_get_current_CallbackFunctionPointer(interrupt, Mock.fwk_interrupt_get_current_CallbackCalls++);
1639 }
1640 if (cmock_call_instance->ReturnThruPtr_interrupt_Used)
1641 {
1642 UNITY_TEST_ASSERT_NOT_NULL(interrupt, cmock_line, CMockStringPtrIsNULL);
1643 memcpy((void*)interrupt, (void*)cmock_call_instance->ReturnThruPtr_interrupt_Val,
1644 cmock_call_instance->ReturnThruPtr_interrupt_Size);
1645 }
1646 UNITY_CLR_DETAILS();
1647 return cmock_call_instance->ReturnVal;
1648 }
1649
1650 void CMockExpectParameters_fwk_interrupt_get_current(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance, unsigned int* interrupt, int interrupt_Depth);
CMockExpectParameters_fwk_interrupt_get_current(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE * cmock_call_instance,unsigned int * interrupt,int interrupt_Depth)1651 void CMockExpectParameters_fwk_interrupt_get_current(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance, unsigned int* interrupt, int interrupt_Depth)
1652 {
1653 cmock_call_instance->Expected_interrupt = interrupt;
1654 cmock_call_instance->Expected_interrupt_Depth = interrupt_Depth;
1655 cmock_call_instance->IgnoreArg_interrupt = 0;
1656 cmock_call_instance->ReturnThruPtr_interrupt_Used = 0;
1657 }
1658
fwk_interrupt_get_current_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1659 void fwk_interrupt_get_current_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1660 {
1661 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE));
1662 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1663 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1664 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1665 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_get_current_CallInstance, cmock_guts_index);
1666 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1667 cmock_call_instance->LineNumber = cmock_line;
1668 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1669 cmock_call_instance->ReturnVal = cmock_to_return;
1670 Mock.fwk_interrupt_get_current_IgnoreBool = (char)1;
1671 }
1672
fwk_interrupt_get_current_CMockStopIgnore(void)1673 void fwk_interrupt_get_current_CMockStopIgnore(void)
1674 {
1675 if(Mock.fwk_interrupt_get_current_IgnoreBool)
1676 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemNext(Mock.fwk_interrupt_get_current_CallInstance);
1677 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1678 }
1679
fwk_interrupt_get_current_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line,int cmock_to_return)1680 void fwk_interrupt_get_current_CMockExpectAnyArgsAndReturn(UNITY_LINE_TYPE cmock_line, int cmock_to_return)
1681 {
1682 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE));
1683 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1684 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1685 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1686 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_get_current_CallInstance, cmock_guts_index);
1687 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1688 cmock_call_instance->LineNumber = cmock_line;
1689 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1690 cmock_call_instance->ReturnVal = cmock_to_return;
1691 cmock_call_instance->ExpectAnyArgsBool = (char)1;
1692 }
1693
fwk_interrupt_get_current_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int * interrupt,int cmock_to_return)1694 void fwk_interrupt_get_current_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int* interrupt, int cmock_to_return)
1695 {
1696 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE));
1697 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1698 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1699 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1700 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_get_current_CallInstance, cmock_guts_index);
1701 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1702 cmock_call_instance->LineNumber = cmock_line;
1703 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1704 CMockExpectParameters_fwk_interrupt_get_current(cmock_call_instance, interrupt, 1);
1705 cmock_call_instance->ReturnVal = cmock_to_return;
1706 }
1707
fwk_interrupt_get_current_AddCallback(CMOCK_fwk_interrupt_get_current_CALLBACK Callback)1708 void fwk_interrupt_get_current_AddCallback(CMOCK_fwk_interrupt_get_current_CALLBACK Callback)
1709 {
1710 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1711 Mock.fwk_interrupt_get_current_CallbackBool = (char)1;
1712 Mock.fwk_interrupt_get_current_CallbackFunctionPointer = Callback;
1713 }
1714
fwk_interrupt_get_current_Stub(CMOCK_fwk_interrupt_get_current_CALLBACK Callback)1715 void fwk_interrupt_get_current_Stub(CMOCK_fwk_interrupt_get_current_CALLBACK Callback)
1716 {
1717 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1718 Mock.fwk_interrupt_get_current_CallbackBool = (char)0;
1719 Mock.fwk_interrupt_get_current_CallbackFunctionPointer = Callback;
1720 }
1721
fwk_interrupt_get_current_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line,unsigned int * interrupt,int interrupt_Depth,int cmock_to_return)1722 void fwk_interrupt_get_current_CMockExpectWithArrayAndReturn(UNITY_LINE_TYPE cmock_line, unsigned int* interrupt, int interrupt_Depth, int cmock_to_return)
1723 {
1724 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_interrupt_get_current_CALL_INSTANCE));
1725 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1726 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1727 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1728 Mock.fwk_interrupt_get_current_CallInstance = CMock_Guts_MemChain(Mock.fwk_interrupt_get_current_CallInstance, cmock_guts_index);
1729 Mock.fwk_interrupt_get_current_IgnoreBool = (char)0;
1730 cmock_call_instance->LineNumber = cmock_line;
1731 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1732 CMockExpectParameters_fwk_interrupt_get_current(cmock_call_instance, interrupt, interrupt_Depth);
1733 cmock_call_instance->ReturnVal = cmock_to_return;
1734 }
1735
fwk_interrupt_get_current_CMockReturnMemThruPtr_interrupt(UNITY_LINE_TYPE cmock_line,unsigned int * interrupt,size_t cmock_size)1736 void fwk_interrupt_get_current_CMockReturnMemThruPtr_interrupt(UNITY_LINE_TYPE cmock_line, unsigned int* interrupt, size_t cmock_size)
1737 {
1738 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_get_current_CallInstance));
1739 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringPtrPreExp);
1740 cmock_call_instance->ReturnThruPtr_interrupt_Used = 1;
1741 cmock_call_instance->ReturnThruPtr_interrupt_Val = interrupt;
1742 cmock_call_instance->ReturnThruPtr_interrupt_Size = cmock_size;
1743 }
1744
fwk_interrupt_get_current_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)1745 void fwk_interrupt_get_current_CMockIgnoreArg_interrupt(UNITY_LINE_TYPE cmock_line)
1746 {
1747 CMOCK_fwk_interrupt_get_current_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_interrupt_get_current_CALL_INSTANCE*)CMock_Guts_GetAddressFor(CMock_Guts_MemEndOfChain(Mock.fwk_interrupt_get_current_CallInstance));
1748 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringIgnPreExp);
1749 cmock_call_instance->IgnoreArg_interrupt = 1;
1750 }
1751
fwk_is_interrupt_context(void)1752 bool fwk_is_interrupt_context(void)
1753 {
1754 UNITY_LINE_TYPE cmock_line = TEST_LINE_NUM;
1755 CMOCK_fwk_is_interrupt_context_CALL_INSTANCE* cmock_call_instance;
1756 UNITY_SET_DETAIL(CMockString_fwk_is_interrupt_context);
1757 cmock_call_instance = (CMOCK_fwk_is_interrupt_context_CALL_INSTANCE*)CMock_Guts_GetAddressFor(Mock.fwk_is_interrupt_context_CallInstance);
1758 Mock.fwk_is_interrupt_context_CallInstance = CMock_Guts_MemNext(Mock.fwk_is_interrupt_context_CallInstance);
1759 if (Mock.fwk_is_interrupt_context_IgnoreBool)
1760 {
1761 UNITY_CLR_DETAILS();
1762 if (cmock_call_instance == NULL)
1763 return Mock.fwk_is_interrupt_context_FinalReturn;
1764 Mock.fwk_is_interrupt_context_FinalReturn = cmock_call_instance->ReturnVal;
1765 return cmock_call_instance->ReturnVal;
1766 }
1767 if (!Mock.fwk_is_interrupt_context_CallbackBool &&
1768 Mock.fwk_is_interrupt_context_CallbackFunctionPointer != NULL)
1769 {
1770 bool cmock_cb_ret = Mock.fwk_is_interrupt_context_CallbackFunctionPointer(Mock.fwk_is_interrupt_context_CallbackCalls++);
1771 UNITY_CLR_DETAILS();
1772 return cmock_cb_ret;
1773 }
1774 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringCalledMore);
1775 cmock_line = cmock_call_instance->LineNumber;
1776 if (Mock.fwk_is_interrupt_context_CallbackFunctionPointer != NULL)
1777 {
1778 cmock_call_instance->ReturnVal = Mock.fwk_is_interrupt_context_CallbackFunctionPointer(Mock.fwk_is_interrupt_context_CallbackCalls++);
1779 }
1780 UNITY_CLR_DETAILS();
1781 return cmock_call_instance->ReturnVal;
1782 }
1783
fwk_is_interrupt_context_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line,bool cmock_to_return)1784 void fwk_is_interrupt_context_CMockIgnoreAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
1785 {
1786 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_is_interrupt_context_CALL_INSTANCE));
1787 CMOCK_fwk_is_interrupt_context_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_is_interrupt_context_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1788 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1789 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1790 Mock.fwk_is_interrupt_context_CallInstance = CMock_Guts_MemChain(Mock.fwk_is_interrupt_context_CallInstance, cmock_guts_index);
1791 Mock.fwk_is_interrupt_context_IgnoreBool = (char)0;
1792 cmock_call_instance->LineNumber = cmock_line;
1793 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1794 cmock_call_instance->ReturnVal = cmock_to_return;
1795 Mock.fwk_is_interrupt_context_IgnoreBool = (char)1;
1796 }
1797
fwk_is_interrupt_context_CMockStopIgnore(void)1798 void fwk_is_interrupt_context_CMockStopIgnore(void)
1799 {
1800 if(Mock.fwk_is_interrupt_context_IgnoreBool)
1801 Mock.fwk_is_interrupt_context_CallInstance = CMock_Guts_MemNext(Mock.fwk_is_interrupt_context_CallInstance);
1802 Mock.fwk_is_interrupt_context_IgnoreBool = (char)0;
1803 }
1804
fwk_is_interrupt_context_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line,bool cmock_to_return)1805 void fwk_is_interrupt_context_CMockExpectAndReturn(UNITY_LINE_TYPE cmock_line, bool cmock_to_return)
1806 {
1807 CMOCK_MEM_INDEX_TYPE cmock_guts_index = CMock_Guts_MemNew(sizeof(CMOCK_fwk_is_interrupt_context_CALL_INSTANCE));
1808 CMOCK_fwk_is_interrupt_context_CALL_INSTANCE* cmock_call_instance = (CMOCK_fwk_is_interrupt_context_CALL_INSTANCE*)CMock_Guts_GetAddressFor(cmock_guts_index);
1809 UNITY_TEST_ASSERT_NOT_NULL(cmock_call_instance, cmock_line, CMockStringOutOfMemory);
1810 memset(cmock_call_instance, 0, sizeof(*cmock_call_instance));
1811 Mock.fwk_is_interrupt_context_CallInstance = CMock_Guts_MemChain(Mock.fwk_is_interrupt_context_CallInstance, cmock_guts_index);
1812 Mock.fwk_is_interrupt_context_IgnoreBool = (char)0;
1813 cmock_call_instance->LineNumber = cmock_line;
1814 cmock_call_instance->ExpectAnyArgsBool = (char)0;
1815 cmock_call_instance->ReturnVal = cmock_to_return;
1816 }
1817
fwk_is_interrupt_context_AddCallback(CMOCK_fwk_is_interrupt_context_CALLBACK Callback)1818 void fwk_is_interrupt_context_AddCallback(CMOCK_fwk_is_interrupt_context_CALLBACK Callback)
1819 {
1820 Mock.fwk_is_interrupt_context_IgnoreBool = (char)0;
1821 Mock.fwk_is_interrupt_context_CallbackBool = (char)1;
1822 Mock.fwk_is_interrupt_context_CallbackFunctionPointer = Callback;
1823 }
1824
fwk_is_interrupt_context_Stub(CMOCK_fwk_is_interrupt_context_CALLBACK Callback)1825 void fwk_is_interrupt_context_Stub(CMOCK_fwk_is_interrupt_context_CALLBACK Callback)
1826 {
1827 Mock.fwk_is_interrupt_context_IgnoreBool = (char)0;
1828 Mock.fwk_is_interrupt_context_CallbackBool = (char)0;
1829 Mock.fwk_is_interrupt_context_CallbackFunctionPointer = Callback;
1830 }
1831
1832