QP/C++  7.4.0-rc.1
Real-Time Embedded Framework
Loading...
Searching...
No Matches
qutest.cpp
Go to the documentation of this file.
1//$file${src::qs::qutest.cpp} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
2//
3// Model: qpcpp.qm
4// File: ${src::qs::qutest.cpp}
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) : qpcpp
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.cpp} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
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.hpp" // QP port
48#include "qp_pkg.hpp" // QP package-scope interface
49#include "qsafe.h" // QP Functional Safety (FuSa) Subsystem
50#include "qs_port.hpp" // QS port
51#include "qs_pkg.hpp" // QS package-scope internal interface
52
53//$skip${QP_VERSION} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
54// Check for the minimum required QP version
55#if (QP_VERSION < 730U) || (QP_VERSION != ((QP_RELEASE^4294967295U) % 0x3E8U))
56#error qpcpp version 7.3.0 or higher required
57#endif
58//$endskip${QP_VERSION} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
59
60//$define${QS::QUTest} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
61namespace QP {
62namespace QS {
63
64} // namespace QS
65} // namespace QP
66//$enddef${QS::QUTest} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
67
68//============================================================================
69//! @cond INTERNAL
70
71namespace QP {
72namespace QS {
73
74TestAttr tstPriv_;
75
76//............................................................................
77void test_pause_() {
78 beginRec_(static_cast<std::uint_fast8_t>(QS_TEST_PAUSED));
79 endRec_();
80 onTestLoop();
81}
82
83//............................................................................
84std::uint32_t getTestProbe_(QSpyFunPtr const api) noexcept {
85 std::uint32_t data = 0U;
86 for (std::uint8_t i = 0U; i < tstPriv_.tpNum; ++i) {
87 if (tstPriv_.tpBuf[i].addr == reinterpret_cast<QSFun>(api)) {
88 data = tstPriv_.tpBuf[i].data;
89
92 QS_MEM_SYS();
93 QS::beginRec_(static_cast<std::uint_fast8_t>(QS_TEST_PROBE_GET));
94 QS_TIME_PRE_(); // timestamp
95 QS_FUN_PRE_(api); // the calling API
96 QS_U32_PRE_(data); // the Test-Probe data
97 QS::endRec_();
98
99 QS_REC_DONE(); // user callback (if defined)
100
101 --tstPriv_.tpNum; // one less Test-Probe
102 // move all remaining entries in the buffer up by one
103 for (std::uint8_t j = i; j < tstPriv_.tpNum; ++j) {
104 tstPriv_.tpBuf[j] = tstPriv_.tpBuf[j + 1U];
105 }
106 QS_MEM_APP();
107 QS_CRIT_EXIT();
108 break; // we are done (Test-Probe retrieved)
109 }
110 }
111 return data;
112}
113
114//............................................................................
116 return (++tstPriv_.testTime);
117}
118
119} // namespace QS
120} // namespace QP
121
122//............................................................................
123extern "C" {
124
126 char const * const module,
127 int_t const id)
128{
129 // NOTE: called in a critical section
130
131 QP::QS::beginRec_(static_cast<std::uint_fast8_t>(QP::QS_ASSERT_FAIL));
132 QS_TIME_PRE_();
133 QS_U16_PRE_(id);
134 QS_STR_PRE_((module != nullptr) ? module : "?");
135 QP::QS::endRec_();
136 QP::QS::onFlush(); // flush the assertion record to the host
137
138 QP::QS::onCleanup(); // cleanup after the failure
139 QP::QS::onReset(); // reset the target to prevent it from continuing
140 for (;;) { // onReset() should not return, but to ensure no-return...
141 }
142}
143
144} // extern "C"
145
146//! @endcond
147//============================================================================
148
149// QP-stub for QUTest
150// NOTE: The QP-stub is needed for unit testing QP applications, but might
151// NOT be needed for testing QP itself. In that case, the build process
152// can define Q_UTEST=0 to exclude the QP-stub from the build.
153#if Q_UTEST != 0
154
155// unnamed namespace for local definitions with internal linkage
156namespace {
157Q_DEFINE_THIS_MODULE("qutest")
158} // unnamed namespace
159
160namespace QP {
161namespace QS {
162
165
166 // return immediately (do nothing) for Test Probe != 0
167 QS_TEST_PROBE(return;)
168
169 while (tstPriv_.readySet.notEmpty()) {
170 std::uint_fast8_t const p = tstPriv_.readySet.findMax();
171 QActive * const a = QActive::registry_[p];
172
173 QEvt const * const e = a->get_();
174 a->dispatch(e, a->getPrio());
175 #if (QF_MAX_EPOOL > 0U)
176 QF::gc(e);
177 #endif
178 if (a->getEQueue().isEmpty()) { // empty queue?
179 tstPriv_.readySet.remove(p);
180#ifndef Q_UNSAFE
181 tstPriv_.readySet.update_(&tstPriv_.readySet_dis);
182#endif
183 }
184 }
185}
186
187} // namespace QS
188} // namespace QP
189
190//$define${QS::QUTest-stub} vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
191namespace QP {
192namespace QF {
193
194//${QS::QUTest-stub::QF::init} ...............................................
195void init() {
196 // Clear the internal QF variables, so that the framework can start
197 // correctly even if the startup code fails to clear the uninitialized
198 // data (as is required by the C++ Standard).
199 bzero_(&QF::priv_, sizeof(QF::priv_));
200 bzero_(&QS::tstPriv_, sizeof(QS::tstPriv_));
202
203 #ifndef Q_UNSAFE
204 QS::tstPriv_.readySet.update_(&QS::tstPriv_.readySet_dis);
205 #endif
206}
207
208//${QS::QUTest-stub::QF::stop} ...............................................
209void stop() {
210 QS::onReset();
211}
212
213//${QS::QUTest-stub::QF::run} ................................................
214int_t run() {
215 // function dictionaries for the standard API
219
222 QS_MEM_SYS();
223
224 // produce the QS_QF_RUN trace record
225 QS_BEGIN_PRE_(QS_QF_RUN, 0U)
226 QS_END_PRE_()
227
228 QS_MEM_APP();
229 QS_CRIT_EXIT();
230
231 QS::processTestEvts_(); // process all events posted so far
232 QS::onTestLoop(); // run the unit test
233 QS::onCleanup(); // application cleanup
234 return 0; // return no error
235}
236
237} // namespace QF
238
239//${QS::QUTest-stub::QActive} ................................................
240
241//${QS::QUTest-stub::QActive::start} .........................................
242void QActive::start(
243 QPrioSpec const prioSpec,
244 QEvt const * * const qSto,
245 std::uint_fast16_t const qLen,
246 void * const stkSto,
247 std::uint_fast16_t const stkSize,
248 void const * const par)
249{
250 Q_UNUSED_PAR(stkSto);
251 Q_UNUSED_PAR(stkSize);
252
253 m_prio = static_cast<std::uint8_t>(prioSpec & 0xFFU); // QF-priol
254 m_pthre = static_cast<std::uint8_t>(prioSpec >> 8U); // preemption-thre.
255 register_(); // make QF aware of this AO
256
257 m_eQueue.init(qSto, qLen); // initialize QEQueue of this AO
258
259 this->init(par, m_prio); // take the top-most initial tran. (virtual)
260}
261
262//${QS::QUTest-stub::QActive::stop} ..........................................
263#ifdef QACTIVE_CAN_STOP
265 unsubscribeAll(); // unsubscribe from all events
266 unregister_(); // remove this object from QF
267}
268
269#endif // def QACTIVE_CAN_STOP
270
271//${QS::QUTest-stub::QTimeEvt} ...............................................
272
273//${QS::QUTest-stub::QTimeEvt::tick1_} .......................................
275 std::uint_fast8_t const tickRate,
276 void const * const sender)
277{
280 QS_MEM_SYS();
281
282 QTimeEvt *prev = &QTimeEvt::timeEvtHead_[tickRate];
283
284 QS_BEGIN_PRE_(QS_QF_TICK, 0U)
285 prev->m_ctr = (prev->m_ctr + 1U);
286 QS_TEC_PRE_(prev->m_ctr); // tick ctr
287 QS_U8_PRE_(tickRate); // tick rate
288 QS_END_PRE_()
289
290 // is current Time Event object provided?
291 QTimeEvt *t = static_cast<QTimeEvt *>(QS::rxPriv_.currObj[QS::TE_OBJ]);
292 if (t != nullptr) {
293
294 // the time event must be armed
295 Q_ASSERT_INCRIT(810, t->m_ctr != 0U);
296
297 QActive * const act = static_cast<QActive *>(t->m_act);
298
299 // the recipient AO must be provided
300 Q_ASSERT_INCRIT(820, act != nullptr);
301
302 // periodic time evt?
303 if (t->m_interval != 0U) {
304 t->m_ctr = t->m_interval; // rearm the time event
305 }
306 else { // one-shot time event: automatically disarm
307 t->m_ctr = 0U; // auto-disarm
308 // mark time event 't' as NOT linked
309 t->refCtr_ = static_cast<std::uint8_t>(t->refCtr_
310 & static_cast<std::uint8_t>(~TE_IS_LINKED));
311
312 QS_BEGIN_PRE_(QS_QF_TIMEEVT_AUTO_DISARM, act->m_prio)
313 QS_OBJ_PRE_(t); // this time event object
314 QS_OBJ_PRE_(act); // the target AO
315 QS_U8_PRE_(tickRate); // tick rate
316 QS_END_PRE_()
317 }
318
319 QS_BEGIN_PRE_(QS_QF_TIMEEVT_POST, act->m_prio)
320 QS_TIME_PRE_(); // timestamp
321 QS_OBJ_PRE_(t); // the time event object
322 QS_SIG_PRE_(t->sig); // signal of this time event
323 QS_OBJ_PRE_(act); // the target AO
324 QS_U8_PRE_(tickRate); // tick rate
325 QS_END_PRE_()
326 QS_MEM_APP();
327 QS_CRIT_EXIT(); // exit critical section before posting
328
329 // asserts if queue overflows
330 static_cast<void>(act->POST(t, sender));
331
333 QS_MEM_SYS();
334 }
335
336 // update the linked list of time events
337 for (;;) {
338 t = prev->m_next; // advance down the time evt. list
339
340 // end of the list?
341 if (t == nullptr) {
342
343 // any new time events armed since the last run of tick()?
344 if (QTimeEvt::timeEvtHead_[tickRate].m_act != nullptr) {
345
346 // sanity check
347 Q_ASSERT_INCRIT(830, prev != nullptr);
348 prev->m_next = QTimeEvt::timeEvtHead_[tickRate].toTimeEvt();
349 QTimeEvt::timeEvtHead_[tickRate].m_act = nullptr;
350 t = prev->m_next; // switch to the new list
351 }
352 else {
353 break; // all currently armed time evts. processed
354 }
355 }
356
357 // time event scheduled for removal?
358 if (t->m_ctr == 0U) {
359 prev->m_next = t->m_next;
360 // mark time event 't' as NOT linked
361 t->refCtr_ = static_cast<std::uint8_t>(t->refCtr_
362 & static_cast<std::uint8_t>(~TE_IS_LINKED));
363 // do NOT advance the prev pointer
364 QS_MEM_APP();
365 QS_CRIT_EXIT(); // exit crit. section to reduce latency
366 }
367 else {
368 prev = t; // advance to this time event
369 QS_MEM_APP();
370 QS_CRIT_EXIT(); // exit crit. section to reduce latency
371 }
372 QS_CRIT_ENTRY(); // re-enter crit. section to continue
373 QS_MEM_SYS();
374 }
375
376 QS_MEM_APP();
377 QS_CRIT_EXIT();
378}
379
380//${QS::QUTest-stub::QHsmDummy} ..............................................
381
382//${QS::QUTest-stub::QHsmDummy::QHsmDummy} ...................................
386
387//${QS::QUTest-stub::QHsmDummy::init} ........................................
389 void const * const e,
390 std::uint_fast8_t const qsId)
391{
392 Q_UNUSED_PAR(e);
393
394 #ifdef Q_SPY
395 if ((QS::priv_.flags & 0x01U) == 0U) {
396 QS::priv_.flags |= 0x01U;
398 }
399 #else
400 Q_UNUSED_PAR(qsId);
401 #endif
402
405 QS_MEM_SYS();
406 QS_BEGIN_PRE_(QS_QEP_STATE_INIT, qsId)
407 QS_OBJ_PRE_(this); // this state machine object
408 QS_FUN_PRE_(m_state.fun); // the source state
409 QS_FUN_PRE_(m_temp.fun); // the target of the initial tran.
410 QS_END_PRE_()
411 QS_MEM_APP();
412 QS_CRIT_EXIT();
413}
414
415//${QS::QUTest-stub::QHsmDummy::dispatch} ....................................
417 QEvt const * const e,
418 std::uint_fast8_t const qsId)
419{
422 QS_MEM_SYS();
423 QS_BEGIN_PRE_(QS_QEP_DISPATCH, qsId)
424 QS_TIME_PRE_(); // time stamp
425 QS_SIG_PRE_(e->sig); // the signal of the event
426 QS_OBJ_PRE_(this); // this state machine object
427 QS_FUN_PRE_(m_state.fun); // the current state
428 QS_END_PRE_()
429 QS_MEM_APP();
430 QS_CRIT_EXIT();
431}
432
433//${QS::QUTest-stub::QActiveDummy} ...........................................
434
435//${QS::QUTest-stub::QActiveDummy::QActiveDummy} .............................
439
440//${QS::QUTest-stub::QActiveDummy::init} .....................................
442 void const * const e,
443 std::uint_fast8_t const qsId)
444{
445 Q_UNUSED_PAR(e);
446 Q_UNUSED_PAR(qsId);
447
448 #ifdef Q_SPY
449 if ((QS::priv_.flags & 0x01U) == 0U) {
450 QS::priv_.flags |= 0x01U;
452 }
453 #endif
454
457 QS_MEM_SYS();
458 QS_BEGIN_PRE_(QS_QEP_STATE_INIT, m_prio)
459 QS_OBJ_PRE_(this); // this state machine object
460 QS_FUN_PRE_(m_state.fun); // the source state
461 QS_FUN_PRE_(m_temp.fun); // the target of the initial tran.
462 QS_END_PRE_()
463 QS_MEM_APP();
464 QS_CRIT_EXIT();
465}
466
467//${QS::QUTest-stub::QActiveDummy::dispatch} .................................
469 QEvt const * const e,
470 std::uint_fast8_t const qsId)
471{
474 QS_MEM_SYS();
475 QS_BEGIN_PRE_(QS_QEP_DISPATCH, qsId)
476 QS_TIME_PRE_(); // time stamp
477 QS_SIG_PRE_(e->sig); // the signal of the event
478 QS_OBJ_PRE_(this); // this state machine object
479 QS_FUN_PRE_(m_state.fun); // the current state
480 QS_END_PRE_()
481 QS_MEM_APP();
482 QS_CRIT_EXIT();
483}
484
485//${QS::QUTest-stub::QActiveDummy::fakePost} .................................
487 QEvt const * const e,
488 std::uint_fast16_t const margin,
489 void const * const sender) noexcept
490{
492
495 QF_MEM_SYS();
496
497 // test-probe#1 for faking queue overflow
498 bool status = true;
500 status = false;
501 if (margin == QF::NO_MARGIN) {
502 // fake assertion Mod=qf_actq,Loc=110
503 Q_onError("qf_actq", 110);
504 }
505 )
506
507 // is it a mutable event?
508 if (e->getPoolNum_() != 0U) {
510 }
511
512 std::uint_fast8_t const rec =
513 (status ? static_cast<std::uint8_t>(QS_QF_ACTIVE_POST)
514 : static_cast<std::uint8_t>(QS_QF_ACTIVE_POST_ATTEMPT));
515 QS_BEGIN_PRE_(rec, m_prio)
516 QS_TIME_PRE_(); // timestamp
517 QS_OBJ_PRE_(sender); // the sender object
518 QS_SIG_PRE_(e->sig); // the signal of the event
519 QS_OBJ_PRE_(this); // this active object
520 QS_2U8_PRE_(e->getPoolNum_(), e->refCtr_); // poolNum & refCtr
521 QS_EQC_PRE_(0U); // # free entries
522 QS_EQC_PRE_(margin); // margin requested
523 QS_END_PRE_()
524
525 QF_MEM_APP();
526 QF_CRIT_EXIT();
527
528 // callback to examine the posted event under the same conditions
529 // as producing the #QS_QF_ACTIVE_POST trace record, which are:
530 // the local filter for this AO ('m_prio') is set
531 if (QS_LOC_CHECK_(m_prio)) {
532 QS::onTestPost(sender, this, e, status);
533 }
534
535 // recycle the event immediately, because it was not really posted
536 #if (QF_MAX_EPOOL > 0U)
537 QF::gc(e);
538 #endif
539
540 return status;
541}
542
543//${QS::QUTest-stub::QActiveDummy::fakePostLIFO} .............................
544void QActiveDummy::fakePostLIFO(QEvt const * const e) noexcept {
546
549 QF_MEM_SYS();
550
551 // test-probe#1 for faking queue overflow
553 // fake assertion Mod=qf_actq,Loc=210
554 Q_onError("qf_actq", 210);
555 )
556
557 // is it a mutable event?
558 if (e->getPoolNum_() != 0U) {
560 }
561
562 QS_BEGIN_PRE_(QS_QF_ACTIVE_POST_LIFO, m_prio)
563 QS_TIME_PRE_(); // timestamp
564 QS_SIG_PRE_(e->sig); // the signal of this event
565 QS_OBJ_PRE_(this); // this active object
566 QS_2U8_PRE_(e->getPoolNum_(), e->refCtr_); // poolNum & refCtr
567 QS_EQC_PRE_(0U); // # free entries
568 QS_EQC_PRE_(0U); // min # free entries
569 QS_END_PRE_()
570
571 QF_MEM_APP();
572 QF_CRIT_EXIT();
573
574 // callback to examine the posted event under the same conditions
575 // as producing the #QS_QF_ACTIVE_POST trace record, which are:
576 // the local filter for this AO ('m_prio') is set
577 if (QS_LOC_CHECK_(m_prio)) {
578 QS::onTestPost(nullptr, this, e, true);
579 }
580 // recycle the event immediately, because it was not really posted
581 #if (QF_MAX_EPOOL > 0U)
582 QF::gc(e);
583 #endif
584}
585
586} // namespace QP
587//$enddef${QS::QUTest-stub} ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
588
589#endif // Q_UTEST != 0
590
591#endif // def Q_UTEST
void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override
Definition qutest.cpp:468
bool fakePost(QEvt const *const e, std::uint_fast16_t const margin, void const *const sender) noexcept
Definition qutest.cpp:486
void fakePostLIFO(QEvt const *const e) noexcept
Definition qutest.cpp:544
void init(void const *const e, std::uint_fast8_t const qsId) override
Definition qutest.cpp:441
Active object class (based on the QHsm implementation strategy)
Definition qp.hpp:722
static QActive * registry_[QF_MAX_ACTIVE+1U]
Definition qp.hpp:748
void stop()
Definition qutest.cpp:264
void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override
Definition qp.hpp:788
bool post_(QEvt const *const e, std::uint_fast16_t const margin, void const *const sender) noexcept
Definition qf_actq.cpp:71
QEvt const * get_() noexcept
Definition qf_actq.cpp:330
void postLIFO(QEvt const *const e) noexcept
Definition qf_actq.cpp:235
std::uint_fast8_t getPrio() const noexcept
Definition qp.hpp:849
QACTIVE_EQUEUE_TYPE const & getEQueue() const noexcept
Definition qp.hpp:861
std::uint8_t m_prio
Definition qp.hpp:724
Abstract State Machine class (state machine interface)
Definition qp.hpp:218
QAsmAttr m_temp
Definition qp.hpp:221
static QState top(void *const me, QEvt const *const e) noexcept
Definition qp.hpp:301
QAsmAttr m_state
Definition qp.hpp:220
Event class.
Definition qp.hpp:137
QSignal sig
Definition qp.hpp:139
std::uint8_t volatile refCtr_
Definition qp.hpp:140
void init(void const *const e, std::uint_fast8_t const qsId) override
Definition qutest.cpp:388
void dispatch(QEvt const *const e, std::uint_fast8_t const qsId) override
Definition qutest.cpp:416
Time Event class.
Definition qp.hpp:953
QTimeEvt * toTimeEvt() noexcept
Definition qp.hpp:1006
static QTimeEvt timeEvtHead_[QF_MAX_TICK_RATE]
Definition qp.hpp:961
static void tick1_(std::uint_fast8_t const tickRate, void const *const sender)
Definition qutest.cpp:274
void * m_act
Definition qp.hpp:956
QTimeEvt *volatile m_next
Definition qp.hpp:955
QTimeEvtCtr volatile m_ctr
Definition qp.hpp:957
QTimeEvtCtr m_interval
Definition qp.hpp:958
void onCleanup()
void gc(QEvt const *const e) noexcept
Definition qf_dyn.cpp:222
void bzero_(void *const start, std::uint_fast16_t const len) noexcept
Definition qf_act.cpp:81
QF::Attr priv_
Definition qf_act.cpp:78
constexpr std::uint_fast16_t NO_MARGIN
Definition qp.hpp:1095
void init()
Definition qk.cpp:369
int_t run()
Definition qk.cpp:397
void stop()
Definition qk.cpp:391
void onTestPost(void const *sender, QActive *recipient, QEvt const *e, bool status)
void onReset()
void onTestLoop()
void processTestEvts_()
Definition qutest.cpp:163
void onCleanup()
@ TE_OBJ
time event object
Definition qs.hpp:995
void onFlush()
QSTimeCtr onGetTime()
QP/C++ framework.
Definition qequeue.hpp:50
std::uint32_t QSTimeCtr
Definition qs.hpp:302
void(*)() QSpyFunPtr
Definition qs.hpp:283
void QEvt_refCtr_inc_(QEvt const *const e) noexcept
Definition qp_pkg.hpp:92
std::uint16_t QPrioSpec
Definition qp.hpp:572
@ QS_QEP_DISPATCH
an event was dispatched (begin of RTC step)
Definition qs.hpp:81
@ QS_ASSERT_FAIL
assertion failed in the code
Definition qs.hpp:170
@ QS_QF_TICK
QTimeEvt tick was called.
Definition qs.hpp:114
@ QS_QF_RUN
QF_run() was entered.
Definition qs.hpp:171
@ QS_QF_TIMEEVT_POST
a time event posted itself directly to an AO
Definition qs.hpp:122
@ QS_TEST_PAUSED
test has been paused
Definition qs.hpp:159
@ QS_QF_TIMEEVT_AUTO_DISARM
a time event expired and was disarmed
Definition qs.hpp:118
@ QS_TEST_PROBE_GET
reports that Test-Probe has been used
Definition qs.hpp:160
@ QS_QF_ACTIVE_POST_ATTEMPT
attempt to post an evt to AO failed
Definition qs.hpp:134
@ QS_QF_ACTIVE_POST_LIFO
an event was posted (LIFO) directly to AO
Definition qs.hpp:90
@ QS_QF_ACTIVE_POST
an event was posted (FIFO) directly to AO
Definition qs.hpp:89
@ QS_QEP_STATE_INIT
an initial transition was taken in a state
Definition qs.hpp:76
int int_t
Definition qp.hpp:103
#define QF_MEM_APP()
Definition qp.hpp:1331
#define Q_UNUSED_PAR(par_)
Definition qp.hpp:539
#define QF_MEM_SYS()
Definition qp.hpp:1326
Internal (package scope) QP/C++ interface.
Sample QP/C++ port.
#define QS_CRIT_STAT
Definition qs.hpp:590
#define QS_TIME_PRE_()
Definition qs.hpp:473
#define QS_REC_DONE()
Definition qs.hpp:392
#define QS_FUN_DICTIONARY(fun_)
Definition qs.hpp:546
#define QS_MEM_APP()
Definition qs.hpp:610
#define QS_TEST_PROBE_DEF(fun_)
Definition qs.hpp:870
#define QS_TEST_PROBE(code_)
Definition qs.hpp:874
#define QS_TEST_PROBE_ID(id_, code_)
Definition qs.hpp:877
#define QS_CRIT_EXIT()
Definition qs.hpp:600
#define QS_MEM_SYS()
Definition qs.hpp:605
#define QS_LOC_CHECK_(qsId_)
Definition qs.hpp:384
#define QS_CRIT_ENTRY()
Definition qs.hpp:595
QS/C++ package-scope interface.
QS/C++ port to a 32-bit CPU, generic C++ compiler.
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
QStateHandler fun
Definition qp.hpp:203