CORDET Framework - C2 Implementation
CrFwOutManagerTestCases.c
Go to the documentation of this file.
1 
19 #include <stdio.h>
20 #include <stdlib.h>
22 #include "CrFwOutStreamStub.h"
23 /* Include FW Profile files */
24 #include "FwSmConstants.h"
25 #include "FwSmConfig.h"
26 #include "FwSmCore.h"
27 #include "FwPrConfig.h"
28 #include "FwPrCore.h"
29 #include "FwPrConstants.h"
30 /* Include framework files */
32 #include "BaseCmp/CrFwBaseCmp.h"
33 #include "Pckt/CrFwPckt.h"
34 #include "OutCmp/CrFwOutCmp.h"
37 #include "CrFwTime.h"
38 #include "CrFwRepErr.h"
40 /* Include configuration files */
41 #include "CrFwOutRegistryUserPar.h"
42 #include "CrFwOutStreamUserPar.h"
43 #include "CrFwOutManagerUserPar.h"
44 #include "CrFwRepErrStub.h"
45 #include "CrFwOutFactoryUserPar.h"
46 #include "CrFwCmpData.h"
47 
48 /* ---------------------------------------------------------------------------------------------*/
50  FwSmDesc_t outManager1, outManagerIll;
51 
52  /* Instantiate the first OutManager */
53  outManager1 = CrFwOutManagerMake(0);
54 
55  /* Check current state of OutManager */
56  if (!CrFwCmpIsInCreated(outManager1))
57  return 0;
58 
59  /* Initialize and Configure OutManager and check success */
60  CrFwCmpInit(outManager1);
61  if (!CrFwCmpIsInInitialized(outManager1))
62  return 0;
63  CrFwCmpReset(outManager1);
64  if (!CrFwCmpIsInConfigured(outManager1))
65  return 0;
66 
67  /* Check Instance and Type Identifiers */
68  if (CrFwCmpGetInstanceId(outManager1) != 0)
69  return 0;
70  if (CrFwCmpGetTypeId(outManager1) != CR_FW_OUTMANAGER_TYPE)
71  return 0;
72 
73  /* Check POCL */
74  if (CrFwOutManagerGetPOCLSize(outManager1) != 3)
75  return 0;
76  if (CrFwOutManagerGetNOfPendingOutCmp(outManager1) != 0)
77  return 0;
78 
79  /* Check counter of loaded OutComponents */
80  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager1) != 0)
81  return 0;
82 
83  /* Attempt to instantiate an OutManager with an illegal identifier */
85  return 0;
87  if (outManagerIll != NULL)
88  return 0;
90  return 0;
91  CrFwSetAppErrCode(crNoAppErr); /* reset application error code */
92 
93  /* Check that there are no allocated packets */
94  if (CrFwPcktGetNOfAllocated() != 0)
95  return 0;
96 
97  /* Check application errors */
99  return 0;
100 
101  return 1;
102 }
103 
104 /* ---------------------------------------------------------------------------------------------*/
106  FwSmDesc_t outManager2, outFactory;
107  FwSmDesc_t outCmp1, outCmp2, outCmp3, outCmp4, outCmp5;
108  CrFwCounterU2_t errRepPosLocal;
109 
110  /* Instantiate the second OutManager */
111  outManager2 = CrFwOutManagerMake(1);
112 
113  /* Initialize and Configure OutManager and check success */
114  CrFwCmpInit(outManager2);
115  CrFwCmpReset(outManager2);
116  if (!CrFwCmpIsInConfigured(outManager2))
117  return 0;
118 
119  /* Check Instance Identifiers */
120  if (CrFwCmpGetInstanceId(outManager2) != 1)
121  return 0;
122 
123  /* Initialize and Configure OutFactory and check success */
128  return 0;
129 
130  /* Create and load four OutComponents (this should fill the OutManager */
131  outCmp1 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
132  if (CrFwOutManagerLoad(outManager2, outCmp1) != 1)
133  return 0;
134  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 1)
135  return 0;
136 
137  outCmp2 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
138  if (CrFwOutManagerLoad(outManager2, outCmp2) != 1)
139  return 0;
140  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 2)
141  return 0;
142 
143  outCmp3 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
144  if (CrFwOutManagerLoad(outManager2, outCmp3) != 1)
145  return 0;
146  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 3)
147  return 0;
148 
149  outCmp4 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
150  if (CrFwOutManagerLoad(outManager2, outCmp4) != 1)
151  return 0;
152  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 4)
153  return 0;
154 
155  /* Store the current value of the error report counter */
156  errRepPosLocal = CrFwRepErrStubGetPos();
157 
158  /* Create and load the fifth OutComponent (this overflows the POCL) */
159  outCmp5 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
160  if (CrFwOutManagerLoad(outManager2, outCmp5) != 0)
161  return 0;
162  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 4)
163  return 0;
164 
165  /* Check that an error report has been generated */
166  if (CrFwRepErrStubGetPos() != errRepPosLocal+1)
167  return 0;
169  return 0;
171  return 0;
173  return 0;
174 
175  /* Reset the OutManager (this should clear the POCL and release all loaded OutComponents) */
176  CrFwCmpReset(outManager2);
177  if (!CrFwCmpIsInConfigured(outManager2))
178  return 0;
179  if (CrFwOutManagerGetNOfPendingOutCmp(outManager2) != 0)
180  return 0;
181  if (CrFwPcktGetNOfAllocated() != 0)
182  return 0;
183 
184  /* Check that there are no allocated packets */
185  if (CrFwPcktGetNOfAllocated() != 0)
186  return 0;
187 
188  /* Check application errors */
189  if (CrFwGetAppErrCode() != crNoAppErr)
190  return 0;
191 
192  return 1;
193 }
194 
195 /* ---------------------------------------------------------------------------------------------*/
197  FwSmDesc_t outManager1, outRegistry, outFactory;
198  FwSmDesc_t sampleOutCmp;
199  FwSmCounterU3_t execCnt;
200 
201  /* Instantiate the first OutManager */
202  outManager1 = CrFwOutManagerMake(0);
203 
204  /* Initialize and Configure OutManager and check success */
205  CrFwCmpInit(outManager1);
206  CrFwCmpReset(outManager1);
207  if (!CrFwCmpIsInConfigured(outManager1))
208  return 0;
209 
210  /* Initialize and Configure OutRegistry and check success */
215  return 0;
216 
217  /* Execute the empty OutManager */
218  CrFwCmpExecute(outManager1);
219  CrFwCmpExecute(outManager1);
220 
221  /* Initialize and Configure OutFactory and check success */
226  return 0;
227 
228  /* Allocate a Sample 1 OutComponent instance */
229  sampleOutCmp = CrFwOutFactoryMakeOutCmp(50,1,0,0);
230  if (!CrFwOutCmpIsInLoaded(sampleOutCmp))
231  return 0;
232 
233  /* Set up enable and ready check of sample OutComponent */
236 
237  /* Load Sample OutComponent in OutManager */
238  if (CrFwOutManagerLoad(outManager1, sampleOutCmp) != 1)
239  return 0;
240  if (CrFwOutManagerGetNOfPendingOutCmp(outManager1) != 1)
241  return 0;
242 
243  /* Store execution counter of Sample OutComponent */
244  execCnt = FwSmGetExecCnt(sampleOutCmp);
245 
246  /* Execute the OutManager */
247  CrFwCmpExecute(outManager1); /* this causes the Sample OutComponent to enter ABORTED and be unloaded */
248  CrFwCmpExecute(outManager1);
249 
250  /* Check that execution was propagated to Sample OutComponent */
251  if (FwSmGetExecCnt(sampleOutCmp) != execCnt+1)
252  return 0;
253  if (FwSmGetStateExecCnt(sampleOutCmp) != 1)
254  return 0;
255  if (!CrFwOutCmpIsInAborted(sampleOutCmp))
256  return 0;
257  if (CrFwOutManagerGetNOfPendingOutCmp(outManager1) != 0)
258  return 0;
260  return 0;
261 
262  /* Check that Sample OutComponent was released by OutManager */
264  return 0;
265 
266  /* Re-allocate, re-load Sample OutComponent in OutManager, and re-register is with OutRegistry */
267  sampleOutCmp = CrFwOutFactoryMakeOutCmp(50,1,0,0);
268  CrFwCmpReset(sampleOutCmp);
269  if (!CrFwOutCmpIsInLoaded(sampleOutCmp))
270  return 0;
271  if (CrFwOutManagerLoad(outManager1, sampleOutCmp) != 1)
272  return 0;
273  if (CrFwOutManagerGetNOfPendingOutCmp(outManager1) != 1)
274  return 0;
275 
276  /* Make Sample OutComponent enabled but not ready */
279 
280  /* Execute the OutManager twice */
281  CrFwCmpExecute(outManager1);
282  CrFwCmpExecute(outManager1);
283 
284  /* Check that execution was propagated to Sample OutComponent */
285  if (!CrFwOutCmpIsInPending(sampleOutCmp))
286  return 0;
287  if (FwSmGetStateExecCnt(sampleOutCmp) != 2)
288  return 0;
289 
290  /* Check that Sample OutComponent is still loaded */
291  if (CrFwOutManagerGetNOfPendingOutCmp(outManager1) != 1)
292  return 0;
294  return 0;
295 
296  /* Reset OutManager (this causes the pending OutComponent to be released) */
297  CrFwCmpReset(outManager1);
298 
299  /* Check that there are no allocated OutComponents */
301  return 0;
302 
303  /* Check that there are no allocated packets */
304  if (CrFwPcktGetNOfAllocated() != 0)
305  return 0;
306 
307  /* Check application errors */
308  if (CrFwGetAppErrCode() != crNoAppErr)
309  return 0;
310 
311  return 1;
312 }
313 
314 /* ---------------------------------------------------------------------------------------------*/
316  FwSmDesc_t outManager4, outRegistry, outFactory, outStream1;
317  FwSmDesc_t sampleOutCmp1, sampleOutCmp2, stdOutCmp1, stdOutCmp2, stdOutCmp3, stdOutCmp4;
318 
319  /* Instantiate the second OutManager */
320  outManager4 = CrFwOutManagerMake(3);
321 
322  /* Initialize and Configure OutManager and check success */
323  CrFwCmpInit(outManager4);
324  CrFwCmpReset(outManager4);
325  if (!CrFwCmpIsInConfigured(outManager4))
326  return 0;
327 
328  /* Initialize and Configure OutRegistry and check success */
333  return 0;
334 
335  /* Initialize and Configure OutFactory and check success */
340  return 0;
341 
342  /* Initialize and Configure the first OutStream */
343  outStream1 = CrFwOutStreamMake(0);
344  FwSmStart(outStream1); /* just in case it had been stopped in some other test case */
345  CrFwCmpInit(outStream1);
346  CrFwCmpReset(outStream1);
347  if (!CrFwCmpIsInConfigured(outStream1))
348  return 0;
349 
350  /* Allocate the OutComponent instances */
351  sampleOutCmp1 = CrFwOutFactoryMakeOutCmp(50,1,0,0);
352  sampleOutCmp2 = CrFwOutFactoryMakeOutCmp(50,1,0,0);
353  stdOutCmp1 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
354  stdOutCmp2 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
355  stdOutCmp3 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
356  stdOutCmp4 = CrFwOutFactoryMakeOutCmp(1,1,0,0);
357  if (!CrFwOutCmpIsInLoaded(sampleOutCmp1))
358  return 0;
359  if (!CrFwOutCmpIsInLoaded(sampleOutCmp2))
360  return 0;
361  if (!CrFwOutCmpIsInLoaded(stdOutCmp1))
362  return 0;
363  if (!CrFwOutCmpIsInLoaded(stdOutCmp2))
364  return 0;
365  if (!CrFwOutCmpIsInLoaded(stdOutCmp3))
366  return 0;
367  if (!CrFwOutCmpIsInLoaded(stdOutCmp4))
368  return 0;
369 
370  /* Set destination of OutComponents to be the same as the first destination of the OutStream */
371  CrFwDestSrc_t dest = CrFwOutStreamGetDest(outStream1, 1);
372  CrFwOutStreamGetDest(outStream1, dest);
373  CrFwOutCmpSetDest(sampleOutCmp1, dest);
374  CrFwOutCmpSetDest(sampleOutCmp2, dest);
375  CrFwOutCmpSetDest(stdOutCmp1, dest);
376  CrFwOutCmpSetDest(stdOutCmp2, dest);
377  CrFwOutCmpSetDest(stdOutCmp3, dest);
378  CrFwOutCmpSetDest(stdOutCmp4, dest);
379 
380  /* Set up enable and ready check of the sample OutComponents */
383 
384  /* Load OutComponents in OutManager */
385  CrFwOutManagerLoad(outManager4, sampleOutCmp1);
386  CrFwOutManagerLoad(outManager4, stdOutCmp1);
387  CrFwOutManagerLoad(outManager4, sampleOutCmp2);
388  CrFwOutManagerLoad(outManager4, stdOutCmp2);
389  if (CrFwOutManagerGetNOfPendingOutCmp(outManager4) != 4)
390  return 0;
391  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager4) != 4)
392  return 0;
393 
394  /* Execute the OutManager twice */
395  CrFwCmpExecute(outManager4);
396  CrFwCmpExecute(outManager4);
397 
398  /* Check that execution was propagated to Sample OutComponent */
399  if (!CrFwOutCmpIsInPending(sampleOutCmp1))
400  return 0;
401  if (!CrFwOutCmpIsInPending(sampleOutCmp2))
402  return 0;
403  if (!CrFwOutCmpIsInTerminated(stdOutCmp1))
404  return 0;
405  if (!CrFwOutCmpIsInTerminated(stdOutCmp2))
406  return 0;
407 
408  /* Check that Sample OutComponents are still loaded */
409  if (CrFwOutManagerGetNOfPendingOutCmp(outManager4) != 2)
410  return 0;
412  return 0;
414  return 0;
416  return 0;
418  return 0;
419  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager4) != 4)
420  return 0;
421 
422  /* Load the third and fourth standard OutComponent */
423  CrFwOutManagerLoad(outManager4, stdOutCmp3);
424  CrFwOutManagerLoad(outManager4, stdOutCmp4);
425  if (CrFwOutManagerGetNOfPendingOutCmp(outManager4) != 4)
426  return 0;
427  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager4) != 6)
428  return 0;
429 
430  /* Execute the OutManager once */
431  CrFwCmpExecute(outManager4);
432 
433  /* Check that Sample OutComponents are still loaded */
434  if (CrFwOutManagerGetNOfPendingOutCmp(outManager4) != 2)
435  return 0;
437  return 0;
439  return 0;
441  return 0;
443  return 0;
444  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager4) != 6)
445  return 0;
446 
447  /* Check that the Standard OutComponents have been released */
449  return 0;
450 
451  /* Shut down OutManager and check that all OutComponents are unloaded and released */
452  CrFwCmpShutdown(outManager4);
453  if (CrFwOutManagerGetNOfPendingOutCmp(outManager4) != 0)
454  return 0;
455 
456  /* Shutdown the OutStream to force all its pending packets to be released */
457  CrFwCmpShutdown(outStream1);
458 
459  /* Check that Sample OutComponents have been released */
461  return 0;
462 
463  /* Bring OutManager back to state CONFIGURED */
464  FwSmStart(outManager4);
465  CrFwCmpInit(outManager4);
466  CrFwCmpReset(outManager4);
467  if (!CrFwCmpIsInConfigured(outManager4))
468  return 0;
469 
470  if (CrFwOutManagerGetNOfLoadedOutCmp(outManager4) != 0)
471  return 0;
472 
474  return 0;
475 
476  /* Check that there are no allocated packets */
477  if (CrFwPcktGetNOfAllocated() != 0)
478  return 0;
479 
480  /* Check application errors */
481  if (CrFwGetAppErrCode() != crNoAppErr)
482  return 0;
483 
484  return 1;
485 }
486 
CrFwInstanceId_t CrFwCmpGetInstanceId(FwSmDesc_t smDesc)
Return the instance identifier of the argument component.
Definition: CrFwBaseCmp.c:150
void CrFwCmpInit(FwSmDesc_t smDesc)
Initialize a framework component.
Definition: CrFwBaseCmp.c:112
CrFwBool_t CrFwCmpIsInInitialized(FwSmDesc_t smDesc)
Return true if the argument component is in state INITIALIZED.
Definition: CrFwBaseCmp.c:172
void CrFwCmpShutdown(FwSmDesc_t smDesc)
Shutdown a framework component.
Definition: CrFwBaseCmp.c:122
CrFwBool_t CrFwCmpIsInConfigured(FwSmDesc_t smDesc)
Return true if the argument component is in state CONFIGURED.
Definition: CrFwBaseCmp.c:177
void CrFwCmpReset(FwSmDesc_t smDesc)
Reset a framework component.
Definition: CrFwBaseCmp.c:117
CrFwBool_t CrFwCmpIsInCreated(FwSmDesc_t smDesc)
Return true if the argument component is in state CREATED.
Definition: CrFwBaseCmp.c:167
void CrFwCmpExecute(FwSmDesc_t smDesc)
Execute a framework component.
Definition: CrFwBaseCmp.c:127
CrFwTypeId_t CrFwCmpGetTypeId(FwSmDesc_t smDesc)
Return the type identifier of the argument component.
Definition: CrFwBaseCmp.c:156
Definition of Base Component.
Definition of the Framework Component Data (FCD) Type.
int CrFwBool_t
Type used for boolean values (1 represent "true" and 0 represents "false").
Definition: CrFwConstants.h:32
#define CR_FW_OUTMANAGER_TYPE
Type identifier for the OutManager component.
static CrFwDestSrc_t dest
Destination.
CrFwBool_t CrFwOutCmpIsInPending(FwSmDesc_t smDesc)
Return true if the argument OutComponent is in state PENDING.
Definition: CrFwOutCmp.c:158
void CrFwOutCmpSetDest(FwSmDesc_t smDesc, CrFwDestSrc_t dest)
Set the destination of the OutComponent.
Definition: CrFwOutCmp.c:192
CrFwBool_t CrFwOutCmpIsInLoaded(FwSmDesc_t smDesc)
Return true if the argument OutComponent is in state LOADED.
Definition: CrFwOutCmp.c:148
CrFwBool_t CrFwOutCmpIsInAborted(FwSmDesc_t smDesc)
Return true if the argument OutComponent is in state ABORTED.
Definition: CrFwOutCmp.c:153
CrFwBool_t CrFwOutCmpIsInTerminated(FwSmDesc_t smDesc)
Return true if the argument OutComponent is in state TERMINATED.
Definition: CrFwOutCmp.c:163
Definition of the OutComponent Component of the framework.
void CrFwOutCmpSample1SetReadyFlag(CrFwBool_t flag)
Set the value of Ready Flag (see CrFwOutCmpSample1ReadyCheck).
void CrFwOutCmpSample1SetEnableFlag(CrFwBool_t flag)
Set the value of Enable Flag (see CrFwOutCmpSample1EnableCheck).
CrFwOutFactoryPoolIndex_t CrFwOutFactoryGetNOfAllocatedOutCmp()
Return the number of OutComponents which are currently allocated.
static FwSmDesc_t outFactory
The singleton instance of the OutFactory.
FwSmDesc_t CrFwOutFactoryMakeOutCmp(CrFwServType_t type, CrFwServSubType_t subType, CrFwDiscriminant_t discriminant, CrFwPcktLength_t length)
Make function for an OutComponent.
FwSmDesc_t CrFwOutFactoryMake()
Factory function for the singleton instance of the OutFactory.
Definition of the OutFactory component.
User-modifiable parameters for the OutFactory component (see CrFwOutFactory.h).
CrFwCounterU1_t CrFwOutManagerGetNOfPendingOutCmp(FwSmDesc_t smDesc)
Return the number of OutComponents currently in the POCL of an OutManager.
CrFwBool_t CrFwOutManagerLoad(FwSmDesc_t smDesc, FwSmDesc_t outCmp)
Load a new OutComponent into the OutManager.
CrFwCounterU1_t CrFwOutManagerGetPOCLSize(FwSmDesc_t smDesc)
Return the size of the POCL of an OutManager.
CrFwCounterU2_t CrFwOutManagerGetNOfLoadedOutCmp(FwSmDesc_t smDesc)
Return the number of OutComponents successfully loaded in the POCL of an OutManager since the OutMana...
FwSmDesc_t CrFwOutManagerMake(CrFwInstanceId_t i)
Factory function to retrieve the i-th OutManager State Machine instance.
CrFwBool_t CrFwOutManagerTestCase2()
Check the load function of an OutManager.
CrFwBool_t CrFwOutManagerTestCase4()
Check the execution function of an OutManager with several OutComponents loaded.
CrFwBool_t CrFwOutManagerTestCase1()
Check the configuration of a newly created OutManager.
CrFwBool_t CrFwOutManagerTestCase3()
Check the execution function of an OutManager with one single OutComponent loaded.
Declaration of the test cases for the OutManager Component (see CrFwOutManager.h).
User-modifiable parameters for the OutManager components (see CrFwOutManager.h).
#define CR_FW_NOF_OUTMANAGER
The number of OutManager components in the application.
FwSmDesc_t CrFwOutRegistryMake()
Factory function for the singleton instance of the OutRegistry.
static FwSmDesc_t outRegistry
The OutRegistry singleton.
CrFwOutRegistryCmdRepState_t CrFwOutRegistryGetState(CrFwInstanceId_t cmdRepId)
Query the OutRegistry for the state of an out-going command or report.
Definition of the OutRegistry Component.
@ crOutRegistryTerminated
Out-going command or report has been passed to the OutStream.
@ crOutRegistryAborted
Out-going command or report has been aborted.
@ crOutRegistryPending
Out-going command or report is pending (waiting to be sent)
User-modifiable parameters for the OutRegistry component (see CrFwOutRegistry.h).
CrFwDestSrc_t CrFwOutStreamGetDest(FwSmDesc_t outStream, CrFwCounterU1_t i)
Return the i-th destination associated to the argument outStream.
FwSmDesc_t CrFwOutStreamMake(CrFwInstanceId_t i)
Factory function to retrieve the i-th OutStream State Machine instance.
Definition of the OutStream component.
Interface for the OutStream stub.
User-modifiable parameters for the OutStream components (see CrFwOutStream.h).
Interface for creating and accessing a report or command packet.
CrFwCounterU2_t CrFwPcktGetNOfAllocated()
Return the number of packets which are currently allocated.
Definition: CrFwPckt.c:214
CrFwInstanceId_t CrFwRepErrStubGetInstanceId(CrFwCounterU2_t errRepPos)
Return the type identifier of the error report at position errRepPos.
Definition: CrFwRepErr.c:277
CrFwCounterU2_t CrFwRepErrStubGetPos()
Return the position in the error report array at which the next error report will be written.
Definition: CrFwRepErr.c:79
CrFwTypeId_t CrFwRepErrStubGetTypeId(CrFwCounterU2_t errRepPos)
Return the type identifier of the error report at position errRepPos.
Definition: CrFwRepErr.c:272
CrFwRepErrCode_t CrFwRepErrStubGetErrCode(CrFwCounterU2_t errRepPos)
Return the error code of the error report at position errRepPos.
Definition: CrFwRepErr.c:267
Interface for reporting an error detected by a framework component.
The CORDET Framework defines an interface for generating error reports (see CrFwRepErr....
Interface through which framework components access the current time.
unsigned char CrFwDestSrc_t
Type used for the command or report destination and source.
unsigned short CrFwCounterU2_t
Type used for unsigned integers with a "medium" range.
@ crOutManagerPoclFull
The Pending OutComponent List (POCL) of an OutManager is full (see CrFwOutManager....
@ crNoAppErr
No application errors have been detected.
@ crOutManagerIllId
A framework function has been called with an illegal OutManager identifier.
CrFwAppErrCode_t CrFwGetAppErrCode()
Return the value of the application error code.
void CrFwSetAppErrCode(CrFwAppErrCode_t errCode)
Set the value of the application error code (see CrFwGetAppErrCode).
Definition of the utility functions for the CORDET Framework.
P&P Software GmbH, Copyright 2012-2013, All Rights Reserved