57 #include "unity_fixture.h"
59 #include "rkhassert_stub.h"
64 #define SIZEOF_BIT_TBL RKH_TRC_MAX_EVENTS_IN_BYTES
65 #define MAX_NUM_BITS (SIZEOF_BIT_TBL * 8)
66 #define FILTER_ON_BYTE 0
67 #define FILTER_OFF_BYTE 0xff
72 TEST_GROUP(trace_filter);
77 static RKH_FilterTbl filStatus;
78 static rui8_t bitTbl[SIZEOF_BIT_TBL];
85 setBitTbl(rui8_t *bt, rui16_t bit, rui8_t value)
90 TEST_ASSERT_TRUE( (bt != (rui8_t *)0) ||
91 (bit < MAX_NUM_BITS) ||
94 bitPos = (rui8_t)(bit & 7);
95 ix = (rui16_t)(bit >> 3);
105 getBitTbl(rui8_t *bt, rui16_t bit)
111 TEST_ASSERT_TRUE( (bt != (rui8_t *)0) ||
112 (bit < MAX_NUM_BITS));
114 bitPos = (rui8_t)(bit & 0x07);
115 ix = (rui16_t)(bit >> 3);
117 bitVal = (*(bt + ix) &
rkh_maptbl[bitPos]) != 0;
123 setAllBitTbl(rui8_t *bt, ruint value, ruint size)
125 TEST_ASSERT_TRUE(bt != (rui8_t *)0);
126 memset(bitTbl, value, size);
131 checkBitTblAreOn(rui8_t *bt, rui16_t size)
137 for (i = 0, p = bt, res =
RKH_OK; i < size; ++i, ++p)
139 if (*p != FILTER_ON_BYTE)
150 setBlockBit(rui8_t *bt, ruint value, ruint to)
154 for (bitPos = 0; bitPos < to; ++bitPos)
156 setBitTbl(bt, bitPos, value);
163 rkh_trc_filterAllOn(rui8_t *ft,
RKH_TE_ID_T ftSize)
168 for (cnt = 0, p = ft; cnt < ftSize; ++cnt, ++p)
176 rkh_trc_filter_init(
void)
178 rkh_trc_filterAllOn(filStatus.signal->tbl,
180 rkh_trc_filterAllOn(filStatus.ao->tbl,
182 rkh_trc_filterAllOn(filStatus.event,
184 rkh_trc_filterAllOn(filStatus.group,
192 TEST_SETUP(trace_filter)
196 TEST_TEAR_DOWN(trace_filter)
207 TEST(trace_filter, getBitIndex0)
209 setAllBitTbl(bitTbl, 0, SIZEOF_BIT_TBL);
212 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 0));
213 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 1));
214 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 7));
217 TEST(trace_filter, getBitIndexX)
219 setAllBitTbl(bitTbl, 0, SIZEOF_BIT_TBL);
224 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 0));
225 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 7));
226 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 8));
227 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 9));
228 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 10));
229 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 22));
230 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 23));
233 TEST(trace_filter, setBitIndex0)
235 setAllBitTbl(bitTbl, 0, SIZEOF_BIT_TBL);
237 setBitTbl(bitTbl, 0, 1);
238 TEST_ASSERT_EQUAL_HEX8(0x01, bitTbl[0]);
239 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 0));
241 setBitTbl(bitTbl, 7, 1);
242 TEST_ASSERT_EQUAL_HEX8(0x81, bitTbl[0]);
243 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 7));
245 TEST_ASSERT_EQUAL_HEX8(0x00, bitTbl[1]);
246 TEST_ASSERT_EQUAL_HEX8(0x00, bitTbl[2]);
247 TEST_ASSERT_EQUAL_HEX8(0x00, bitTbl[3]);
250 TEST(trace_filter, resetBitIndex0)
252 setAllBitTbl(bitTbl, 0xff, SIZEOF_BIT_TBL);
254 setBitTbl(bitTbl, 0, 0);
255 TEST_ASSERT_EQUAL_HEX8(0xfe, bitTbl[0]);
256 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 0));
258 setBitTbl(bitTbl, 7, 0);
259 TEST_ASSERT_EQUAL_HEX8(0x7e, bitTbl[0]);
260 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 7));
262 TEST_ASSERT_EQUAL_HEX8(0xff, bitTbl[1]);
263 TEST_ASSERT_EQUAL_HEX8(0xff, bitTbl[2]);
264 TEST_ASSERT_EQUAL_HEX8(0xff, bitTbl[3]);
267 TEST(trace_filter, setBitIndexX)
269 setAllBitTbl(bitTbl, 0, SIZEOF_BIT_TBL);
271 setBitTbl(bitTbl, 8, 1);
272 TEST_ASSERT_EQUAL_HEX8(0x01, bitTbl[1]);
273 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 8));
275 setBitTbl(bitTbl, 17, 1);
276 TEST_ASSERT_EQUAL_HEX8(0x02, bitTbl[2]);
277 TEST_ASSERT_EQUAL(1, getBitTbl(bitTbl, 17));
279 TEST_ASSERT_EQUAL_HEX8(0x00, bitTbl[0]);
280 TEST_ASSERT_EQUAL_HEX8(0x00, bitTbl[3]);
283 TEST(trace_filter, resetBitIndexX)
285 setAllBitTbl(bitTbl, 0xff, SIZEOF_BIT_TBL);
287 setBitTbl(bitTbl, 8, 0);
288 TEST_ASSERT_EQUAL_HEX8(0xfe, bitTbl[1]);
289 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 8));
291 setBitTbl(bitTbl, 17, 0);
292 TEST_ASSERT_EQUAL_HEX8(0xfd, bitTbl[2]);
293 TEST_ASSERT_EQUAL(0, getBitTbl(bitTbl, 17));
295 TEST_ASSERT_EQUAL_HEX8(0xff, bitTbl[0]);
296 TEST_ASSERT_EQUAL_HEX8(0xff, bitTbl[3]);
307 rkh_trc_filter_init();
309 rkh_assertStub_reset();
312 TEST_TEAR_DOWN(trace)
323 TEST(trace, filEventsAreOnAfterInit)
325 TEST_ASSERT_TRUE(checkBitTblAreOn(filStatus.signal->tbl,
326 filStatus.signal->size) ==
RKH_OK);
328 TEST_ASSERT_TRUE(checkBitTblAreOn(filStatus.ao->tbl,
329 filStatus.ao->size) ==
RKH_OK);
331 TEST_ASSERT_TRUE(checkBitTblAreOn(filStatus.event,
334 TEST_ASSERT_TRUE(checkBitTblAreOn(filStatus.group,
338 TEST(trace, turnOffOneFilEvent)
340 RKH_GM_OFFSET_T offset;
342 offset = RKH_SM_TTBL_OFFSET;
343 bitTbl[offset] = 0x01;
347 TEST_ASSERT_EQUAL(1, getBitTbl(&filStatus.event[offset], 0));
348 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
350 TEST_ASSERT_EQUAL_HEX8(0x01,
352 TEST_ASSERT_EQUAL_HEX8(0x08, *filStatus.group);
355 TEST(trace, turnOnOneFilEvent)
357 bitTbl[RKH_SM_TTBL_OFFSET + 0] = 0x02;
363 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
365 TEST_ASSERT_EQUAL_HEX8(0x08, *filStatus.group);
368 TEST(trace, turnOffMultipleFilEvent)
370 RKH_GM_OFFSET_T offset;
372 offset = RKH_SM_TTBL_OFFSET;
373 bitTbl[offset] = 0x01;
374 bitTbl[offset + 1] = 0x01;
379 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
383 TEST(trace, allOffFilEvent)
388 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
390 TEST_ASSERT_EQUAL_HEX8(0xff, *filStatus.group);
393 TEST(trace, allOnFilEvent)
396 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
398 TEST_ASSERT_EQUAL_HEX8(0x00, *filStatus.group);
401 TEST(trace, isOnOffFilEvent)
406 setBitTbl(filStatus.group,
RKH_TG_MP, FILTER_OFF);
413 TEST(trace, upperAndLowerBoundsFilEvent)
421 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
425 TEST(trace, setAllEventsFromOneGroup)
430 filterTo = RKH_SM_END;
431 offset = filStatus.grpFilMap[GETGRP(
RKH_SM_START)].offset;
432 setBlockBit(&bitTbl[offset], 1, filterTo - filterFrom);
434 for (filter = filterFrom; filter < filterTo; ++filter)
439 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
443 TEST(trace, outOfBoundsProducesRuntimeError)
446 TEST_ASSERT_EQUAL_STRING(
"RKH assertion", rkh_assertStub_getLastError());
449 TEST(trace, turnOffOneGroup)
452 TEST_ASSERT_EQUAL_HEX8(0x01, *filStatus.group);
455 TEST(trace, turnOnOneGroup)
459 TEST_ASSERT_EQUAL_HEX8(0x00, *filStatus.group);
462 TEST(trace, allOnOffGroup)
465 TEST_ASSERT_EQUAL_HEX8(0xff, *filStatus.group);
467 TEST_ASSERT_EQUAL_HEX8(0x00, *filStatus.group);
470 TEST(trace, turnOnOffMultipleGroups)
475 TEST_ASSERT_EQUAL_HEX8(0x89, *filStatus.group);
480 TEST_ASSERT_EQUAL_HEX8(0x00, *filStatus.group);
483 TEST(trace, turnOffOneGroupChangedItsEventFilters)
485 RKHROM RKH_GMTBL_T *pTrcMap;
488 TEST_ASSERT_EQUAL_HEX8(0x80, *filStatus.group);
490 pTrcMap = &filStatus.grpFilMap[
RKH_TG_UT];
491 memset(&bitTbl[pTrcMap->offset], FILTER_OFF_BYTE, pTrcMap->range);
493 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.event,
497 TEST(trace, turnOffOneSymFil)
501 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
504 TEST(trace, turnOnOneSymFil)
509 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
512 TEST(trace, turnOnOffMultipleSymFil)
518 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
521 TEST(trace, allOffOnSymFil)
523 setAllBitTbl(bitTbl, FILTER_OFF_BYTE, RKH_TRC_MAX_SMA);
525 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
527 setAllBitTbl(bitTbl, FILTER_ON_BYTE, RKH_TRC_MAX_SMA);
529 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
532 TEST(trace, isOnOffSymFil)
536 setBitTbl(filStatus.ao->tbl, 0, FILTER_OFF);
537 setBitTbl(filStatus.ao->tbl, 3, FILTER_OFF);
541 setBitTbl(filStatus.ao->tbl, 0, FILTER_ON);
545 TEST(trace, upperAndLowerBoundsSymFil)
547 setBitTbl(bitTbl, 0, FILTER_OFF);
548 setBitTbl(bitTbl, RKH_TRC_MAX_SMA * 8, FILTER_OFF);
553 TEST_ASSERT_EQUAL_MEMORY(bitTbl, filStatus.ao->tbl, RKH_TRC_MAX_SMA);
556 TEST(trace, outOfBoundsProducesRuntimeErrorSymFil)
558 rkh_trc_symFil(filStatus.ao, (filStatus.ao->size * 8) + 1, FILTER_OFF);
559 TEST_ASSERT_EQUAL_STRING(
"RKH assertion", rkh_assertStub_getLastError());
562 TEST_ASSERT_EQUAL_STRING(
"RKH assertion", rkh_assertStub_getLastError());
#define RKH_FAIL
Standard define.
Entry symbol table for memory object.
rui8_t RKH_TG_T
Group of events.
void rkh_trc_filter_event_(rui8_t ctrl, RKH_TE_ID_T evt)
Emit or suppress a specific event.
Initializes the previously allocated memory pool data strcuture RKH_MP_T.
void rkh_trc_filter_group_(rui8_t ctrl, RKH_TG_T grp, rui8_t mode)
Emit or suppress all trace events from a specific group.
Inits a previously created state machine calling its initializing action.
#define RKH_OK
Standard define.
#define RKH_TRC_ALL_GROUPS
Emit or suppress tracing for all groups and events.
Unit test harness group (UT)
#define RKH_FALSE
Standard define.
Destination state or pseudostate of a transition segment.
rui8_t RKH_TE_ID_T
Describes a trace event identification (ID).
#define RKH_TRC_MAX_EVENTS_IN_BYTES
Defines the size of trace filter table according to RKH_TOT_NUM_TRC_EVTS and RKH_TRC_MAX_EVENTS.
RKHROM rui8_t rkh_maptbl[8]
rkh_maptbl[] is a table in ROM, used to equate an index from 0 to 7 to a bit mask.
void rkh_trc_symFil(const RKH_TRC_FIL_T *filter, RKH_TRC_FSLOT slot, rui8_t mode)
Emmit or suppresse trace events related to a particular active object or event signal.
void rkh_trc_filter_get(RKH_FilterTbl *outFilterTbl)
Get a memory reference to every trace filter table.
#define RKH_TRUE
Standard define.
#define RKH_TRC_ALL_EVENTS
Emit or suppress all trace events.
RKH framwwork platform - independent interface.
rbool_t rkh_trc_symFil_isoff(const RKH_TRC_FIL_T *filter, RKH_TRC_FSLOT slot)
Test the active objecto or signal filter condition.
rbool_t rkh_trc_isoff_(RKH_TE_ID_T e)
Test the group and event filter condition.
#define RKH_SM_START
Trace event offset.
#define RKH_TRC_SET_ALL(mode_)
Emit or supress tracing for all signal/active objects.
Erase the history of a state. It can be a shallow or deep history.