QP/C  7.4.0-rc.2
Real-Time Embedded Framework
Loading...
Searching...
No Matches
qutest.c
Go to the documentation of this file.
1//$file${src::qs::qutest.c} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
2//
3// Model: qpc.qm
4// File: ${src::qs::qutest.c}
5//
6// This code has been generated by QM 6.1.1 <www.state-machine.com/qm>.
7// DO NOT EDIT THIS FILE MANUALLY. All your changes will be lost.
8//
9// This code is covered by the following QP license:
10// License # : LicenseRef-QL-dual
11// Issued to : Any user of the QP/C real-time embedded framework
12// Framework(s) : qpc
13// Support ends : 2024-12-31
14// License scope:
15//
16// Copyright (C) 2005 Quantum Leaps, LLC <state-machine.com>.
17//
18// Q u a n t u m L e a P s
19// ------------------------
20// Modern Embedded Software
21//
22// SPDX-License-Identifier: GPL-3.0-or-later OR LicenseRef-QL-commercial
23//
24// This software is dual-licensed under the terms of the open source GNU
25// General Public License version 3 (or any later version), or alternatively,
26// under the terms of one of the closed source Quantum Leaps commercial
27// licenses.
28//
29// The terms of the open source GNU General Public License version 3
30// can be found at: <www.gnu.org/licenses/gpl-3.0>
31//
32// The terms of the closed source Quantum Leaps commercial licenses
33// can be found at: <www.state-machine.com/licensing>
34//
35// Redistributions in source code must retain this top-level comment block.
36// Plagiarizing this software to sidestep the license obligations is illegal.
37//
38// Contact information:
39// <www.state-machine.com/licensing>
40// <info@state-machine.com>
41//
42//$endhead${src::qs::qutest.c} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
43// only build when Q_UTEST is defined
44#ifdef Q_UTEST
45
46#define QP_IMPL // this is QP implementation
47#include "qp_port.h" // QP port
48#include "qp_pkg.h" // QP package-scope interface
49#include "qsafe.h" // QP Functional Safety (FuSa) Subsystem
50#include "qs_port.h" // include QS port
51#include "qs_pkg.h" // QS facilities for pre-defined trace records
52
53//============================================================================
54// QUTest unit testing harness
55//$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
56// Check for the minimum required QP version
57#if (QP_VERSION < 730U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
58#error qpc version 7.3.0 or higher required
59#endif
60//$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
61
62//$define${QS::QUTest} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
63//$enddef${QS::QUTest} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
64
65//============================================================================
66//! @cond INTERNAL
67
68QSTestAttr QS_tstPriv_;
69
70//............................................................................
71void QS_test_pause_(void) {
72 QS_beginRec_((uint_fast8_t)QS_TEST_PAUSED);
73 QS_endRec_();
74 QS_onTestLoop();
75}
76
77//............................................................................
78uint32_t QS_getTestProbe_(QSpyFunPtr const api) {
79 uint32_t data = 0U;
80 for (uint_fast8_t i = 0U; i < QS_tstPriv_.tpNum; ++i) {
81 if (QS_tstPriv_.tpBuf[i].addr == (QSFun)api) {
82 data = QS_tstPriv_.tpBuf[i].data;
83
86 QS_MEM_SYS();
87 QS_beginRec_((uint_fast8_t)QS_TEST_PROBE_GET);
88 QS_TIME_PRE_(); // timestamp
89 QS_FUN_PRE_(api); // the calling API
90 QS_U32_PRE_(data); // the Test-Probe data
91 QS_endRec_();
92
93 QS_REC_DONE(); // user callback (if defined)
94
95 --QS_tstPriv_.tpNum; // one less Test-Probe
96 // move all remaining entries in the buffer up by one
97 for (uint_fast8_t j = i; j < QS_tstPriv_.tpNum; ++j) {
98 QS_tstPriv_.tpBuf[j] = QS_tstPriv_.tpBuf[j + 1U];
99 }
100 QS_MEM_APP();
101 QS_CRIT_EXIT();
102 break; // we are done (Test-Probe retrieved)
103 }
104 }
105 return data;
106}
107
108//............................................................................
109QSTimeCtr QS_onGetTime(void) {
110 return (++QS_tstPriv_.testTime);
111}
112
113//............................................................................
115 char const * const module,
116 int_t const id)
117{
118 // NOTE: called in a critical section
119
120 QS_beginRec_((uint_fast8_t)QS_ASSERT_FAIL);
121 QS_TIME_PRE_();
122 QS_U16_PRE_(id);
123 QS_STR_PRE_((module != (char *)0) ? module : "?");
124 QS_endRec_();
125 QS_onFlush(); // flush the assertion record to the host
126
127 QS_onCleanup(); // cleanup before resetting
128 QS_onReset(); // reset the target to prevent the code from continuing
129 for (;;) { // QS_onReset() should not return, but to ensure no-return
130 }
131}
132
133//! @endcond
134//============================================================================
135
136// QP-stub for QUTest
137// NOTE: The QP-stub is needed for unit testing QP applications, but might
138// NOT be needed for testing QP itself. In that case, the build process
139// can define Q_UTEST=0 to exclude the QP-stub from the build.
140#if (Q_UTEST != 0)
141
142Q_DEFINE_THIS_MODULE("qutest")
143
144//............................................................................
145void QS_processTestEvts_(void) {
146 QS_TEST_PROBE_DEF(&QS_processTestEvts_)
147
148 // return immediately (do nothing) for Test Probe != 0
149 QS_TEST_PROBE(return;)
150
151 while (QPSet_notEmpty(&QS_tstPriv_.readySet)) {
152 uint_fast8_t const p = QPSet_findMax(&QS_tstPriv_.readySet);
153 QActive * const a = QActive_registry_[p];
154
155 QEvt const * const e = QActive_get_(a);
156 QASM_DISPATCH(a, e, a->prio);
157#if (QF_MAX_EPOOL > 0U)
158 QF_gc(e);
159#endif
160 if (a->eQueue.frontEvt == (QEvt *)0) { // empty queue?
161 QPSet_remove(&QS_tstPriv_.readySet, p);
162#ifndef Q_UNSAFE
163 QPSet_update_(&QS_tstPriv_.readySet, &QS_tstPriv_.readySet_dis);
164#endif
165 }
166 }
167}
168
169//$define${QS::QUTest-stub} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
170
171//${QS::QUTest-stub::QF::init} ...............................................
172void QF_init(void) {
173 // Clear the internal QF variables, so that the framework can start
174 // correctly even if the startup code fails to clear the uninitialized
175 // data (as is required by the C Standard).
176 QF_bzero_(&QF_priv_, sizeof(QF_priv_));
177 QF_bzero_(&QS_tstPriv_, sizeof(QS_tstPriv_));
178 QF_bzero_(&QActive_registry_[0], sizeof(QActive_registry_));
179
180 #ifndef Q_UNSAFE
181 QPSet_update_(&QS_tstPriv_.readySet, &QS_tstPriv_.readySet_dis);
182 #endif
183}
184
185//${QS::QUTest-stub::QF::stop} ...............................................
186void QF_stop(void) {
187 QS_onReset();
188}
189
190//${QS::QUTest-stub::QF::run} ................................................
192 // function dictionaries for the standard API
193 QS_FUN_DICTIONARY(&QActive_post_);
194 QS_FUN_DICTIONARY(&QActive_postLIFO_);
195 QS_FUN_DICTIONARY(&QS_processTestEvts_);
196
199 QS_MEM_SYS();
200
201 // produce the QS_QF_RUN trace record
202 QS_BEGIN_PRE_(QS_QF_RUN, 0U)
203 QS_END_PRE_()
204
205 QS_MEM_APP();
206 QS_CRIT_EXIT();
207
208 QS_processTestEvts_(); // process all events posted so far
209 QS_onTestLoop(); // run the test loop
210 QS_onCleanup(); // application cleanup
211 return 0; // return no error
212}
213
214//${QS::QUTest-stub::QActive} ................................................
215
216//${QS::QUTest-stub::QActive::start_} ........................................
217//! @private @memberof QActive
218void QActive_start_(QActive * const me,
219 QPrioSpec const prioSpec,
220 QEvt const * * const qSto,
221 uint_fast16_t const qLen,
222 void * const stkSto,
223 uint_fast16_t const stkSize,
224 void const * const par)
225{
226 Q_UNUSED_PAR(stkSto);
227 Q_UNUSED_PAR(stkSize);
228
229 me->prio = (uint8_t)(prioSpec & 0xFFU); // QF-prio. of the AO
230 me->pthre = (uint8_t)(prioSpec >> 8U); // preemption-threshold
231 QActive_register_(me); // make QF aware of this active object
232
233 QEQueue_init(&me->eQueue, qSto, qLen);
234
235 // top-most initial tran. (virtual call)
236 (*me->super.vptr->init)(&me->super, par, me->prio);
237}
238
239//${QS::QUTest-stub::QActive::stop} ..........................................
240#ifdef QACTIVE_CAN_STOP
241//! @protected @memberof QActive
242void QActive_stop(QActive * const me) {
243 QActive_unsubscribeAll(me); // unsubscribe from all events
244 QActive_unregister_(me); // un-register this active object
245}
246#endif // def QACTIVE_CAN_STOP
247
248//${QS::QUTest-stub::QTimeEvt} ...............................................
249
250//${QS::QUTest-stub::QTimeEvt::tick1_} .......................................
251//! @private @memberof QTimeEvt
252void QTimeEvt_tick1_(
253 uint_fast8_t const tickRate,
254 void const * const sender)
255{
258 QS_MEM_SYS();
259
260 QTimeEvt *prev = &QTimeEvt_timeEvtHead_[tickRate];
261
262 QS_BEGIN_PRE_(QS_QF_TICK, 0U)
263 ++prev->ctr;
264 QS_TEC_PRE_(prev->ctr); // tick ctr
265 QS_U8_PRE_(tickRate); // tick rate
266 QS_END_PRE_()
267
268 // is current Time Event object provided?
269 QTimeEvt *t = (QTimeEvt *)QS_rxPriv_.currObj[TE_OBJ];
270 if (t != (QTimeEvt *)0) {
271
272 // the time event must be armed
273 Q_ASSERT_INCRIT(810, t->ctr != 0U);
274
275 QActive * const act = (QActive *)(t->act);
276
277 // the recipient AO must be provided
278 Q_ASSERT_INCRIT(820, act != (QActive *)0);
279
280 // periodic time evt?
281 if (t->interval != 0U) {
282 t->ctr = t->interval; // rearm the time event
283 }
284 else { // one-shot time event: automatically disarm
285 t->ctr = 0U; // auto-disarm
286 // mark time event 't' as NOT linked
287 t->super.refCtr_ &= (uint8_t)(~(uint8_t)QTE_IS_LINKED);
288
289 QS_BEGIN_PRE_(QS_QF_TIMEEVT_AUTO_DISARM, act->prio)
290 QS_OBJ_PRE_(t); // this time event object
291 QS_OBJ_PRE_(act); // the target AO
292 QS_U8_PRE_(tickRate); // tick rate
293 QS_END_PRE_()
294 }
295
296 QS_BEGIN_PRE_(QS_QF_TIMEEVT_POST, act->prio)
297 QS_TIME_PRE_(); // timestamp
298 QS_OBJ_PRE_(t); // the time event object
299 QS_SIG_PRE_(t->super.sig); // signal of this time event
300 QS_OBJ_PRE_(act); // the target AO
301 QS_U8_PRE_(tickRate); // tick rate
302 QS_END_PRE_()
303 QS_MEM_APP();
304 QS_CRIT_EXIT(); // exit critical section before posting
305
306 QACTIVE_POST(act, &t->super, sender); // asserts if queue overflows
307
309 QS_MEM_SYS();
310 }
311
312 // update the linked list of time events
313 for (;;) {
314 t = prev->next; // advance down the time evt. list
315
316 // end of the list?
317 if (t == (QTimeEvt *)0) {
318
319 // any new time events armed since the last QTimeEvt_tick_()?
320 if (QTimeEvt_timeEvtHead_[tickRate].act != (void *)0) {
321
322 // sanity check
323 Q_ASSERT_INCRIT(830, prev != (QTimeEvt *)0);
324 prev->next = (QTimeEvt *)QTimeEvt_timeEvtHead_[tickRate].act;
325 QTimeEvt_timeEvtHead_[tickRate].act = (void *)0;
326 t = prev->next; // switch to the new list
327 }
328 else {
329 break; // all currently armed time evts. processed
330 }
331 }
332
333 // time event scheduled for removal?
334 if (t->ctr == 0U) {
335 prev->next = t->next;
336 // mark time event 't' as NOT linked
337 t->super.refCtr_ &= (uint8_t)(~(uint8_t)QTE_IS_LINKED);
338 // do NOT advance the prev pointer
339 QS_MEM_APP();
340 QS_CRIT_EXIT(); // exit crit. section to reduce latency
341 }
342 else {
343 prev = t; // advance to this time event
344 QS_MEM_APP();
345 QS_CRIT_EXIT(); // exit crit. section to reduce latency
346 }
347 QS_CRIT_ENTRY(); // re-enter crit. section to continue
348 QS_MEM_SYS();
349 }
350
351 QS_MEM_APP();
352 QS_CRIT_EXIT();
353}
354
355//${QS::QUTest-stub::QHsmDummy} ..............................................
356
357//${QS::QUTest-stub::QHsmDummy::ctor} ........................................
358//! @public @memberof QHsmDummy
359void QHsmDummy_ctor(QHsmDummy * const me) {
360 static struct QAsmVtable const vtable = {
361 &QHsmDummy_init_,
362 &QHsmDummy_dispatch_,
363 &QHsm_isIn_
364 #ifdef Q_SPY
365 ,&QHsm_getStateHandler_
366 #endif
367 };
368 me->super.vptr = &vtable; // hook the vptr
369}
370
371//${QS::QUTest-stub::QHsmDummy::init_} .......................................
372//! @private @memberof QHsmDummy
373void QHsmDummy_init_(
374 QAsm * const me,
375 void const * const par,
376 uint_fast8_t const qsId)
377{
378 Q_UNUSED_PAR(par);
379
380 #ifdef Q_SPY
381 if ((QS_priv_.flags & 0x01U) == 0U) {
382 QS_priv_.flags |= 0x01U;
383 QS_FUN_DICTIONARY(&QHsm_top);
384 }
385 #endif
386
389 QS_MEM_SYS();
390 QS_BEGIN_PRE_(QS_QEP_STATE_INIT, qsId)
391 QS_OBJ_PRE_(me); // this state machine object
392 QS_FUN_PRE_(me->state.fun); // the source state
393 QS_FUN_PRE_(me->temp.fun); // the target of the initial tran.
394 QS_END_PRE_()
395 QS_MEM_APP();
396 QS_CRIT_EXIT();
397}
398
399//${QS::QUTest-stub::QHsmDummy::dispatch_} ...................................
400//! @private @memberof QHsmDummy
401void QHsmDummy_dispatch_(
402 QAsm * const me,
403 QEvt const * const e,
404 uint_fast8_t const qsId)
405{
408 QS_MEM_SYS();
409 QS_BEGIN_PRE_(QS_QEP_DISPATCH, qsId)
410 QS_TIME_PRE_(); // time stamp
411 QS_SIG_PRE_(e->sig); // the signal of the event
412 QS_OBJ_PRE_(me); // this state machine object
413 QS_FUN_PRE_(me->state.fun); // the current state
414 QS_END_PRE_()
415 QS_MEM_APP();
416 QS_CRIT_EXIT();
417}
418
419//${QS::QUTest-stub::QActiveDummy} ...........................................
420
421//${QS::QUTest-stub::QActiveDummy::ctor} .....................................
422//! @public @memberof QActiveDummy
423void QActiveDummy_ctor(QActiveDummy * const me) {
424 // superclass' ctor
425 QActive_ctor(&me->super, Q_STATE_CAST(0));
426
427 static struct QAsmVtable const vtable = {
428 &QActiveDummy_init_,
429 &QActiveDummy_dispatch_,
430 &QHsm_isIn_
431 #ifdef Q_SPY
432 ,&QHsm_getStateHandler_
433 #endif
434 };
435 me->super.super.vptr = &vtable; // hook the vptr
436}
437
438//${QS::QUTest-stub::QActiveDummy::init_} ....................................
439//! @private @memberof QActiveDummy
440void QActiveDummy_init_(
441 QAsm * const me,
442 void const * const par,
443 uint_fast8_t const qsId)
444{
445 Q_UNUSED_PAR(qsId);
446
447 QHsmDummy_init_(me, par, ((QActive const *)me)->prio);
448}
449
450//${QS::QUTest-stub::QActiveDummy::dispatch_} ................................
451//! @private @memberof QActiveDummy
452void QActiveDummy_dispatch_(
453 QAsm * const me,
454 QEvt const * const e,
455 uint_fast8_t const qsId)
456{
457 Q_UNUSED_PAR(qsId);
458
459 QHsmDummy_dispatch_(me, e, ((QActive const *)me)->prio);
460}
461
462//${QS::QUTest-stub::QActiveDummy::fakePost_} ................................
463//! @private @memberof QActiveDummy
464bool QActiveDummy_fakePost_(
465 QActive * const me,
466 QEvt const * const e,
467 uint_fast16_t const margin,
468 void const * const sender)
469{
470 QS_TEST_PROBE_DEF(&QActive_post_)
471
474 QF_MEM_SYS();
475
476 // test-probe#1 for faking queue overflow
477 bool status = true;
479 status = false;
480 if (margin == QF_NO_MARGIN) {
481 // fake assertion Mod=qf_actq,Loc=110
482 Q_onError("qf_actq", 110);
483 }
484 )
485
486 // is it a mutable event?
487 if (QEvt_getPoolNum_(e) != 0U) {
488 QEvt_refCtr_inc_(e);
489 }
490
491 uint_fast8_t const rec = (status ? (uint_fast8_t)QS_QF_ACTIVE_POST
492 : (uint_fast8_t)QS_QF_ACTIVE_POST_ATTEMPT);
493 QS_BEGIN_PRE_(rec, me->prio)
494 QS_TIME_PRE_(); // timestamp
495 QS_OBJ_PRE_(sender); // the sender object
496 QS_SIG_PRE_(e->sig); // the signal of the event
497 QS_OBJ_PRE_(me); // this active object
498 QS_2U8_PRE_(QEvt_getPoolNum_(e), e->refCtr_); // poolNum & refCtr
499 QS_EQC_PRE_(0U); // # free entries
500 QS_EQC_PRE_(margin); // margin requested
501 QS_END_PRE_()
502
503 QF_MEM_APP();
504 QF_CRIT_EXIT();
505
506 // callback to examine the posted event under the same conditions
507 // as producing the #QS_QF_ACTIVE_POST trace record, which are:
508 // the local filter for this AO ('me->prio') is set
509 if (QS_LOC_CHECK_(me->prio)) {
510 QS_onTestPost(sender, me, e, status);
511 }
512
513 // recycle the event immediately, because it was not really posted
514 #if (QF_MAX_EPOOL > 0U)
515 QF_gc(e);
516 #endif
517
518 return status; // the event is "posted" correctly
519}
520
521//${QS::QUTest-stub::QActiveDummy::fakePostLIFO_} ............................
522//! @private @memberof QActiveDummy
523void QActiveDummy_fakePostLIFO_(
524 QActive * const me,
525 QEvt const * const e)
526{
527 QS_TEST_PROBE_DEF(&QActive_postLIFO_)
528
531 QF_MEM_SYS();
532
533 // test-probe#1 for faking queue overflow
535 // fake assertion Mod=qf_actq,Loc=210
536 Q_onError("qf_actq", 210);
537 )
538
539 // is it a mutable event?
540 if (QEvt_getPoolNum_(e) != 0U) {
541 QEvt_refCtr_inc_(e);
542 }
543
544 QS_BEGIN_PRE_(QS_QF_ACTIVE_POST_LIFO, me->prio)
545 QS_TIME_PRE_(); // timestamp
546 QS_SIG_PRE_(e->sig); // the signal of this event
547 QS_OBJ_PRE_(me); // this active object
548 QS_2U8_PRE_(QEvt_getPoolNum_(e), e->refCtr_); // poolNum & refCtr
549 QS_EQC_PRE_(0U); // # free entries
550 QS_EQC_PRE_(0U); // min # free entries
551 QS_END_PRE_()
552
553 QF_MEM_APP();
554 QF_CRIT_EXIT();
555
556 // callback to examine the posted event under the same conditions
557 // as producing the #QS_QF_ACTIVE_POST trace record, which are:
558 // the local filter for this AO ('me->prio') is set
559 if (QS_LOC_CHECK_(me->prio)) {
560 QS_onTestPost((QActive *)0, me, e, true);
561 }
562 // recycle the event immediately, because it was not really posted
563 #if (QF_MAX_EPOOL > 0U)
564 QF_gc(e);
565 #endif
566}
567//$enddef${QS::QUTest-stub} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
568
569#endif // Q_UTEST != 0
570
571#endif // Q_UTEST
QF_Attr QF_priv_
Definition qf_act.c:71
#define QF_MEM_APP()
Definition qp.h:1288
#define Q_UNUSED_PAR(par_)
Definition qp.h:536
#define QF_NO_MARGIN
Definition qp.h:1158
#define Q_STATE_CAST(handler_)
Definition qp.h:530
#define QF_MEM_SYS()
Definition qp.h:1283
int int_t
Definition qp.h:104
#define QACTIVE_POST(me_, e_, sender_)
Definition qp.h:1207
#define QASM_DISPATCH(me_, e_, qsId_)
Definition qp.h:479
uint16_t QPrioSpec
Definition qp.h:623
Internal (package scope) QP/C interface.
#define QTE_IS_LINKED
Definition qp_pkg.h:82
Sample QP/C port.
@ QS_ASSERT_FAIL
assertion failed in the code
Definition qs.h:178
@ QS_QF_TIMEEVT_AUTO_DISARM
a time event expired and was disarmed
Definition qs.h:126
@ QS_QF_RUN
QF_run() was entered.
Definition qs.h:179
@ QS_TEST_PROBE_GET
reports that Test-Probe has been used
Definition qs.h:168
@ QS_QEP_STATE_INIT
an initial transition was taken in a state
Definition qs.h:84
#define QS_CRIT_STAT
Definition qs.h:568
#define QS_TIME_PRE_()
Definition qs.h:450
#define QS_REC_DONE()
Definition qs.h:388
#define QS_FUN_DICTIONARY(fun_)
Definition qs.h:517
@ QS_QF_ACTIVE_POST_LIFO
an event was posted (LIFO) directly to AO
Definition qs.h:98
@ QS_QF_TIMEEVT_POST
a time event posted itself directly to an AO
Definition qs.h:130
uint32_t QSTimeCtr
Definition qs.h:309
#define QS_MEM_APP()
Definition qs.h:588
@ QS_QF_ACTIVE_POST_ATTEMPT
attempt to post an evt to AO failed
Definition qs.h:142
@ TE_OBJ
time event object
Definition qs.h:964
@ QS_QF_TICK
QTimeEvt tick was called.
Definition qs.h:122
@ QS_QEP_DISPATCH
an event was dispatched (begin of RTC step)
Definition qs.h:89
#define QS_TEST_PROBE_DEF(fun_)
Definition qs.h:846
@ QS_TEST_PAUSED
test has been paused
Definition qs.h:167
@ QS_QF_ACTIVE_POST
an event was posted (FIFO) directly to AO
Definition qs.h:97
#define QS_TEST_PROBE(code_)
Definition qs.h:849
#define QS_TEST_PROBE_ID(id_, code_)
Definition qs.h:852
#define QS_CRIT_EXIT()
Definition qs.h:578
#define QS_MEM_SYS()
Definition qs.h:583
#define QS_LOC_CHECK_(qsId_)
Definition qs.h:382
#define QS_CRIT_ENTRY()
Definition qs.h:573
QS/C package-scope interface.
Sample QS/C port.
QP Functional Safety (FuSa) Subsystem.
#define Q_NORETURN
Definition qsafe.h:161
#define QF_CRIT_ENTRY()
Definition qsafe.h:58
Q_NORETURN Q_onError(char const *const module, int_t const id)
#define Q_ASSERT_INCRIT(id_, expr_)
Definition qsafe.h:72
#define QF_CRIT_EXIT()
Definition qsafe.h:62
#define QF_CRIT_STAT
Definition qsafe.h:54
int_t QF_run(void)
Definition qutest.c:191
void QF_init(void)
Definition qutest.c:172
void QF_stop(void)
Definition qutest.c:186
Dummy Active Object for testing.
Definition qs.h:807
QActive super
Definition qs.h:809
Active object class (based on the QHsm implementation strategy)
Definition qp.h:804
QACTIVE_EQUEUE_TYPE eQueue
Definition qp.h:826
QAsm super
Definition qp.h:806
uint8_t prio
Definition qp.h:809
uint8_t pthre
Definition qp.h:812
Abstract State Machine class (state machine interface)
Definition qp.h:280
struct QAsmVtable const * vptr
Definition qp.h:284
union QAsmAttr state
Definition qp.h:289
union QAsmAttr temp
Definition qp.h:292
Virtual table for the QAsm class.
Definition qp.h:301
void(* init)(QAsm *const me, void const *const e, uint_fast8_t const qsId)
Definition qp.h:302
Event class.
Definition qp.h:145
QSignal sig
Definition qp.h:149
uint8_t volatile refCtr_
Definition qp.h:154
Dummy HSM class for testing.
Definition qs.h:778
QAsm super
Definition qs.h:780
Time Event class.
Definition qp.h:973
struct QTimeEvt *volatile next
Definition qp.h:980
void *volatile act
Definition qp.h:983
QTimeEvtCtr volatile ctr
Definition qp.h:986
QTimeEvtCtr interval
Definition qp.h:989
QEvt super
Definition qp.h:975
QStateHandler fun
Definition qp.h:268