RKH
Loading...
Searching...
No Matches
test_rkhsm.c
Go to the documentation of this file.
1/*
2 * --------------------------------------------------------------------------
3 *
4 * Framework RKH
5 * -------------
6 *
7 * State-machine framework for reactive embedded systems
8 *
9 * Copyright (C) 2010 Leandro Francucci.
10 * All rights reserved. Protected by international copyright laws.
11 *
12 *
13 * RKH is free software: you can redistribute it and/or modify it under the
14 * terms of the GNU General Public License as published by the Free Software
15 * Foundation, either version 3 of the License, or (at your option) any
16 * later version.
17 *
18 * RKH is distributed in the hope that it will be useful, but WITHOUT ANY
19 * WARRANTY; without even the implied warranty of MERCHANTABILITY or
20 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
21 * more details.
22 *
23 * You should have received a copy of the GNU General Public License along
24 * with RKH, see copying.txt file.
25 *
26 * Contact information:
27 * RKH site: http://vortexmakes.com/que-es/
28 * RKH GitHub: https://github.com/vortexmakes/RKH
29 * RKH Sourceforge: https://sourceforge.net/projects/rkh-reactivesys/
30 * e-mail: lf@vortexmakes.com
31 * ---------------------------------------------------------------------------
32 */
33
46/* -------------------------- Development history -------------------------- */
47/*
48 * 2016.12.15 LeFr v2.4.05 ---
49 */
50
51/* -------------------------------- Authors -------------------------------- */
52/*
53 * LeFr Leandro Francucci lf@vortexmakes.com
54 */
55
56/* --------------------------------- Notes --------------------------------- */
57/* ----------------------------- Include files ----------------------------- */
58#include <unitrazer.h>
59#include <tzlink.h>
60#include <tzparse.h>
61#include "rkhsm.h"
62#include "common.h"
63
64#include "smTest.h"
65#include "Mock_smTestAct.h"
66
67#include "smPseudoConditionalTest.h"
68#include "Mock_smPseudoConditionalTestAct.h"
69
70#include "smPseudoTest.h"
71#include "Mock_smPseudoTestAct.h"
72
73#include "smInitialPseudoTest.h"
74#include "Mock_smInitialPseudoTestAct.h"
75
76#include "Mock_rkhassert.h"
77#include "rkhport.h"
78#include "rkhfwk_bittbl.h"
79#include "rkhtrc.h"
80#include "rkhtrc_filter.h"
81#include "rkhtrc_record.h"
82#include "rkhtrc_stream.h"
83
84/* ----------------------------- Local macros ------------------------------ */
85/* ------------------------------- Constants ------------------------------- */
86
87static RKH_STATIC_EVENT(evA, A);
88static RKH_STATIC_EVENT(evB, B);
89static RKH_STATIC_EVENT(evC, C);
90static RKH_STATIC_EVENT(evD, D);
91static RKH_STATIC_EVENT(evE, E);
92static RKH_STATIC_EVENT(evF, F);
93static RKH_STATIC_EVENT(evG, G);
94static RKH_STATIC_EVENT(evH, H);
95static RKH_STATIC_EVENT(evI, I);
96static RKH_STATIC_EVENT(evTerminate, TERMINATE);
97extern const RKH_EVT_T evCompletion;
98extern const RKH_EVT_T evCreation;
99
100/* ---------------------------- Local data types --------------------------- */
101typedef struct StateMachine
102{
103 RKH_SM_T sm;
104 int foo;
105} StateMachine;
106
107typedef struct Composite
108{
109 RKH_SMA_T ao;
110 int foo;
111 RKH_SM_T itsReactivePart;
112} Composite;
113
114/* ---------------------------- Global variables --------------------------- */
115/* ---------------------------- Local variables ---------------------------- */
116static const RKH_ST_T *targetStates[16], *exitStates[16], *entryStates[16];
117static RKH_ST_T *expectedState;
118static RKH_RCODE_T result;
119static int first = 1;
120
121/* ----------------------- Local function prototypes ----------------------- */
122/* ---------------------------- Local functions ---------------------------- */
123static
124void
125setUpUnitrazer(void)
126{
127 if(first)
128 {
129 tzlink_open(0, NULL);
130 }
131
132 first = 0;
133
134 sm_init();
135 sm_ntrnact_ignore();
136}
137
138static
139void
140setUpWoutUnitrazer(void)
141{
142 sm_ignore();
143}
144
145static
146void
147loadStateMachineSymbols(void)
148{
149 RKH_TR_FWK_SIG(A);
150 RKH_TR_FWK_SIG(B);
151 RKH_TR_FWK_SIG(C);
152 RKH_TR_FWK_SIG(D);
153 RKH_TR_FWK_SIG(E);
154 RKH_TR_FWK_SIG(F);
155
156 RKH_TR_FWK_AO(smTest);
157 RKH_TR_FWK_STATE(smTest, &waiting);
158 RKH_TR_FWK_STATE(smTest, &s0);
159 RKH_TR_FWK_STATE(smTest, &s1);
160 RKH_TR_FWK_STATE(smTest, &s2);
161 RKH_TR_FWK_STATE(smTest, &s21);
162 RKH_TR_FWK_STATE(smTest, &s22);
163 RKH_TR_FWK_STATE(smTest, &s221);
164 RKH_TR_FWK_STATE(smTest, &s2211);
165 RKH_TR_FWK_STATE(smTest, &s222);
166 RKH_TR_FWK_STATE(smTest, &s2221);
167 RKH_TR_FWK_STATE(smTest, &s22211);
168 RKH_TR_FWK_STATE(smTest, &s3);
169 RKH_TR_FWK_STATE(smTest, &s31);
170 RKH_TR_FWK_STATE(smTest, &s4);
171 RKH_TR_FWK_STATE(smTest, &s5);
172 RKH_TR_FWK_STATE(smTest, &s2Final);
173 RKH_TR_FWK_STATE(smTest, &SmTest_Final);
174
175 RKH_TR_FWK_AO(smPseudoConditionalTest);
176 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_waiting);
177 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice1);
178 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice2);
179 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice3);
180 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice4);
181 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice5);
182 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_choice6);
183 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_s0);
184 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_s1);
185 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_s11);
186 RKH_TR_FWK_STATE(smPseudoConditionalTest, &smPCT_s12);
187
188 RKH_TR_FWK_AO(smPseudoTest);
189 RKH_TR_FWK_STATE(smPseudoTest, &smPT_waiting);
190 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s0);
191 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s1);
192 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s11);
193 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s12);
194 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s1Hist);
195 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s121);
196 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s122);
197 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s12Hist);
198 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s2);
199 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s21);
200 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s22);
201 RKH_TR_FWK_STATE(smPseudoTest, &smPT_s2Hist);
202
203 RKH_TR_FWK_AO(smInitialPseudoTest);
204 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s0);
205 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s1);
206 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s11);
207 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s12);
208 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s2);
209 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s21);
210 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s211);
211 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s3);
212 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s31);
213 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s32);
214 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s33);
215 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s331);
216 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s4);
217 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s41);
218 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s411);
219 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s5);
220 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s51);
221 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s511);
222 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s52);
223 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s6);
224 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s61);
225 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s62);
226 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s1Hist);
227 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s2Hist);
228 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s3Hist);
229 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s7);
230 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s71);
231 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s72);
232 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_choice1);
233 RKH_TR_FWK_STATE(smInitialPseudoTest, &smIPT_s5Final);
234
235 RKH_TR_FWK_AO(smInitial6);
236 RKH_TR_FWK_STATE(smInitial6, &smI6_s0);
237 RKH_TR_FWK_STATE(smInitial6, &smI6_s1);
238}
239
240static
241void
242setRKHTraceFilters(void)
243{
244 RKH_FILTER_OFF_ALL_SIGNALS();
245 RKH_FILTER_OFF_GROUP_ALL_EVENTS(RKH_TG_SM);
246 RKH_FILTER_OFF_SMA(smTest);
247 RKH_FILTER_OFF_SMA(smPseudoConditionalTest);
248 RKH_FILTER_OFF_SMA(smPseudoTest);
249 RKH_FILTER_OFF_SMA(smInitialPseudoTest);
250 RKH_FILTER_OFF_EVENT(RKH_TE_FWK_ASSERT);
251}
252
253static void
254MockEffectCallback0(SmTest *const me, RKH_EVT_T *pe, int cmock_num_calls)
255{
256 TEST_ASSERT_NULL(getPropagatedEvent(smTest));
257 rkh_sm_propagate(RKH_UPCAST(RKH_SM_T, me), &evD);
258 TEST_ASSERT_NOT_NULL(getPropagatedEvent(smTest));
259}
260
261static void
262MockEffectCallback1(SmTest *const me, RKH_EVT_T *pe, int cmock_num_calls)
263{
264 TEST_ASSERT_NULL(getPropagatedEvent(smTest));
265}
266
267/* ---------------------------- Global functions --------------------------- */
268void
269setUp(void)
270{
271 setUpUnitrazer();
272
273 Mock_smTestAct_Init();
274 Mock_smPseudoConditionalTestAct_Init();
275 Mock_smInitialPseudoTestAct_Init();
276
277 loadStateMachineSymbols();
278 setRKHTraceFilters();
279
280 rkh_sm_clear_history(&smPT_s1Hist);
281 rkh_sm_clear_history(&smPT_s12Hist);
282 rkh_sm_clear_history(&smPT_s2Hist);
283 rkh_sm_clear_history(&smIPT_s1Hist);
284}
285
286void
287tearDown(void)
288{
289 sm_verify(); /* Makes sure there are no unused expectations, if */
290 /* there are, this function causes the test to fail. */
291 sm_cleanup();
292
293 Mock_smTestAct_Verify();
294 Mock_smTestAct_Destroy();
295
296 Mock_smPseudoConditionalTestAct_Verify();
297 Mock_smPseudoConditionalTestAct_Destroy();
298
299 Mock_smInitialPseudoTestAct_Verify();
300 Mock_smInitialPseudoTestAct_Destroy();
301}
302
309void
310test_transitionFirstStateAfterInit(void)
311{
312 UtrzProcessOut *p;
313
314 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
315 sm_init_expect(RKH_STATE_CAST(&waiting));
316 sm_trn_expect(RKH_STATE_CAST(&waiting), RKH_STATE_CAST(&waiting));
317 sm_tsState_expect(RKH_STATE_CAST(&waiting));
318 sm_enstate_expect(RKH_STATE_CAST(&waiting));
319 sm_nenex_expect(1, 0);
320 sm_state_expect(RKH_STATE_CAST(&waiting));
321 sm_evtProc_expect();
322
323 rkh_sm_init((RKH_SM_T *)smTest);
324
325 p = unitrazer_getLastOut();
326 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
327}
328
329void
330test_transitionSimpleToSimpleAtEqualLevel(void)
331{
332 UtrzProcessOut *p;
333
334 stateList_create(targetStates, 1, &s1);
335 stateList_create(entryStates, 1, &s1);
336 stateList_create(exitStates, 1, &s0);
337
338 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
339 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
340 smTest_tr11_Expect(RKH_CAST(SmTest, smTest), &evA);
341 smTest_nS1_Expect(RKH_CAST(SmTest, smTest));
342
343 setProfile(smTest, RKH_STATE_CAST(&waiting),
344 RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s0),
345 targetStates,
346 entryStates, exitStates, RKH_STATE_CAST(&s1), 1,
347 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evA,
348 RKH_STATE_CAST(&s0));
349
350 rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
351
352 p = unitrazer_getLastOut();
353 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
354}
355
356void
357test_transitionSimpleToSimpleFromHighToLowLevel(void)
358{
359 UtrzProcessOut *p;
360
361 stateList_create(targetStates, 1, &s21);
362 stateList_create(entryStates, 2, &s2, &s21);
363 stateList_create(exitStates, 1, &s0);
364
365 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
366 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
367 smTest_tr12_Expect(RKH_CAST(SmTest, smTest), &evB);
368 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
369 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
370
371 setProfile(smTest, RKH_STATE_CAST(&waiting),
372 RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s0),
373 targetStates,
374 entryStates, exitStates, RKH_STATE_CAST(&s21), 1,
375 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evB,
376 RKH_STATE_CAST(&s0));
377
378 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
379
380 p = unitrazer_getLastOut();
381 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
382}
383
384void
385test_transitionSimpleToSimpleFromLowToHighLevel(void)
386{
387 UtrzProcessOut *p;
388
389 stateList_create(targetStates, 1, &s0);
390 stateList_create(entryStates, 1, &s0);
391 stateList_create(exitStates, 2, &s21, &s2);
392
393 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
394 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
395 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
396 smTest_tr13_Expect(RKH_CAST(SmTest, smTest), &evB);
397 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
398
399 setProfile(smTest, RKH_STATE_CAST(&waiting),
400 RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s21),
401 targetStates,
402 entryStates, exitStates, RKH_STATE_CAST(&s0), 1,
403 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evB,
404 RKH_STATE_CAST(&s21));
405
406 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
407
408 p = unitrazer_getLastOut();
409 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
410}
411
412void
413test_transitionSimpleToCompositeAtEqualLevel(void)
414{
415 UtrzProcessOut *p;
416 int nExSt, nEnSt;
417 RKH_EVT_T event;
418
419 nEnSt = 2;
420 nExSt = 1;
421 event = evC;
422
423 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
424 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
425 smTest_tr21_Expect(RKH_CAST(SmTest, smTest), &event);
426 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
427 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
428 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
429
430 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
431 sm_dch_expect(event.e, RKH_STATE_CAST(&s0));
432 sm_trn_expect(RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s2));
433 sm_tsState_expect(RKH_STATE_CAST(&s2));
434 sm_exstate_expect(RKH_STATE_CAST(&s0));
435 sm_enstate_expect(RKH_STATE_CAST(&s2));
436 sm_tsState_expect(RKH_STATE_CAST(&s21));
437 sm_enstate_expect(RKH_STATE_CAST(&s21));
438 sm_nenex_expect(nEnSt, nExSt);
439 sm_state_expect(RKH_STATE_CAST(&s21));
440 sm_evtProc_expect();
441
442 rkh_sm_init((RKH_SM_T *)smTest);
443 setState(smTest, RKH_STATE_CAST(&s0));
444 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
445
446 p = unitrazer_getLastOut();
447 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
448}
449
450void
451test_transitionSimpleToCompositeFromHighToLowLevel(void)
452{
453 UtrzProcessOut *p;
454 int nExSt, nEnSt;
455 RKH_EVT_T event;
456
457 nEnSt = 4;
458 nExSt = 1;
459 event = evD;
460
461 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
462 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
463 smTest_tr22_Expect(RKH_CAST(SmTest, smTest), &event);
464 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
465 smTest_nS22_Expect(RKH_CAST(SmTest, smTest));
466 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
467 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
468 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
469 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
470
471 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
472 sm_dch_expect(event.e, RKH_STATE_CAST(&s0));
473 sm_trn_expect(RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s22));
474 sm_tsState_expect(RKH_STATE_CAST(&s22));
475 sm_exstate_expect(RKH_STATE_CAST(&s0));
476 sm_enstate_expect(RKH_STATE_CAST(&s2));
477 sm_enstate_expect(RKH_STATE_CAST(&s22));
478 sm_tsState_expect(RKH_STATE_CAST(&s221));
479 sm_enstate_expect(RKH_STATE_CAST(&s221));
480 sm_tsState_expect(RKH_STATE_CAST(&s2211));
481 sm_enstate_expect(RKH_STATE_CAST(&s2211));
482 sm_nenex_expect(nEnSt, nExSt);
483 sm_state_expect(RKH_STATE_CAST(&s2211));
484 sm_evtProc_expect();
485
486 rkh_sm_init((RKH_SM_T *)smTest);
487 setState(smTest, RKH_STATE_CAST(&s0));
488 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
489
490 p = unitrazer_getLastOut();
491 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
492}
493
494void
495test_transitionSimpleToCompositeFromLowToHighLevel(void)
496{
497 UtrzProcessOut *p;
498 int nExSt, nEnSt;
499 RKH_EVT_T event;
500
501 nEnSt = 1;
502 nExSt = 1;
503 event = evC;
504
505 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
506 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
507 smTest_tr23_Expect(RKH_CAST(SmTest, smTest), &event);
508 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
509 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
510
511 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
512 sm_dch_expect(event.e, RKH_STATE_CAST(&s21));
513 sm_trn_expect(RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s2));
514 sm_tsState_expect(RKH_STATE_CAST(&s2));
515 sm_exstate_expect(RKH_STATE_CAST(&s21));
516 sm_tsState_expect(RKH_STATE_CAST(&s21));
517 sm_enstate_expect(RKH_STATE_CAST(&s21));
518 sm_nenex_expect(nEnSt, nExSt);
519 sm_state_expect(RKH_STATE_CAST(&s21));
520 sm_evtProc_expect();
521
522 rkh_sm_init((RKH_SM_T *)smTest);
523 setState(smTest, RKH_STATE_CAST(&s21));
524 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
525
526 p = unitrazer_getLastOut();
527 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
528}
529
530void
531test_transitionCompositeToSimpleAtEqualLevel(void)
532{
533 UtrzProcessOut *p;
534
535 stateList_create(targetStates, 1, &s0);
536 stateList_create(entryStates, 1, &s0);
537 stateList_create(exitStates, 2, &s21, &s2);
538
539 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
540 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
541 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
542 smTest_tr31_Expect(RKH_CAST(SmTest, smTest), &evA);
543 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
544
545 setProfile(smTest, RKH_STATE_CAST(&waiting),
546 RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s2),
547 targetStates,
548 entryStates, exitStates, RKH_STATE_CAST(&s0), 1,
549 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evA,
550 RKH_STATE_CAST(&s21));
551
552 rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
553
554 p = unitrazer_getLastOut();
555 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
556}
557
558void
559test_transitionCompositeToSimpleFromHighToLowLevel(void)
560{
561 UtrzProcessOut *p;
562
563 stateList_create(targetStates, 1, &s21);
564 stateList_create(entryStates, 1, &s21);
565 stateList_create(exitStates, 1, &s21);
566
567 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
568 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
569 smTest_tr32_Expect(RKH_CAST(SmTest, smTest), &evD);
570 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
571
572 setProfile(smTest, RKH_STATE_CAST(&waiting),
573 RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s2),
574 targetStates,
575 entryStates, exitStates, RKH_STATE_CAST(&s21), 1,
576 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evD,
577 RKH_STATE_CAST(&s21));
578
579 rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
580
581 p = unitrazer_getLastOut();
582 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
583}
584
585void
586test_transitionLoopSimpleStateOnTop(void)
587{
588 UtrzProcessOut *p;
589
590 stateList_create(targetStates, 1, &s1);
591 stateList_create(entryStates, 1, &s1);
592 stateList_create(exitStates, 1, &s1);
593
594 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
595 smTest_xS1_Expect(RKH_CAST(SmTest, smTest));
596 smTest_tr53_Expect(RKH_CAST(SmTest, smTest), &evA);
597 smTest_nS1_Expect(RKH_CAST(SmTest, smTest));
598
599 setProfile(smTest, RKH_STATE_CAST(&waiting),
600 RKH_STATE_CAST(&s1), RKH_STATE_CAST(&s1),
601 targetStates,
602 entryStates, exitStates, RKH_STATE_CAST(&s1), 1,
603 TRN_NOT_INTERNAL, INIT_STATE_MACHINE, &evA,
604 RKH_STATE_CAST(&s1));
605
606 rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
607
608 p = unitrazer_getLastOut();
609 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
610}
611
612void
613test_transitionLoopNestedSimpleState(void)
614{
615 UtrzProcessOut *p;
616
617 stateList_create(targetStates, 1, &s31);
618 stateList_create(entryStates, 1, &s31);
619 stateList_create(exitStates, 1, &s31);
620
621 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
622 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
623 smTest_tr52_Expect(RKH_CAST(SmTest, smTest), &evD);
624 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
625
626 setProfile(smTest, RKH_STATE_CAST(&waiting),
627 RKH_STATE_CAST(&s31), RKH_STATE_CAST(&s31),
628 targetStates, entryStates, exitStates,
629 RKH_STATE_CAST(&s31), 1, TRN_NOT_INTERNAL, INIT_STATE_MACHINE,
630 &evD, RKH_STATE_CAST(&s31));
631
632 rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
633
634 p = unitrazer_getLastOut();
635 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
636}
637
638void
639test_transitionLoopCompositeStateOnTop(void)
640{
641 UtrzProcessOut *p;
642 int nExSt, nEnSt;
643 RKH_EVT_T event;
644
645 nEnSt = 1;
646 nExSt = 1;
647 event = evA;
648
649 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
650 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
651 smTest_tr51_Expect(RKH_CAST(SmTest, smTest), &event);
652 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
653 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
654
655 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
656 sm_dch_expect(event.e, RKH_STATE_CAST(&s31));
657 sm_trn_expect(RKH_STATE_CAST(&s3), RKH_STATE_CAST(&s3));
658 sm_tsState_expect(RKH_STATE_CAST(&s3));
659 sm_exstate_expect(RKH_STATE_CAST(&s31));
660 sm_tsState_expect(RKH_STATE_CAST(&s31));
661 sm_enstate_expect(RKH_STATE_CAST(&s31));
662 sm_nenex_expect(nEnSt, nExSt);
663 sm_state_expect(RKH_STATE_CAST(&s31));
664 sm_evtProc_expect();
665
666 rkh_sm_init((RKH_SM_T *)smTest);
667 setState(smTest, RKH_STATE_CAST(&s31));
668 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
669
670 p = unitrazer_getLastOut();
671 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
672}
673
674void
675test_transitionLoopNestedCompositeState(void)
676{
677 UtrzProcessOut *p;
678 int nExSt, nEnSt;
679 RKH_EVT_T event;
680
681 nEnSt = 2;
682 nExSt = 2;
683 event = evD;
684
685 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
686 smTest_xS2211_Expect(RKH_CAST(SmTest, smTest));
687 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
688 smTest_tr54_Expect(RKH_CAST(SmTest, smTest), &event);
689 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
690 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
691 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
692 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
693
694 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
695 sm_dch_expect(event.e, RKH_STATE_CAST(&s2211));
696 sm_trn_expect(RKH_STATE_CAST(&s22), RKH_STATE_CAST(&s22));
697 sm_tsState_expect(RKH_STATE_CAST(&s22));
698 sm_exstate_expect(RKH_STATE_CAST(&s2211));
699 sm_exstate_expect(RKH_STATE_CAST(&s221));
700 sm_tsState_expect(RKH_STATE_CAST(&s221));
701 sm_enstate_expect(RKH_STATE_CAST(&s221));
702 sm_tsState_expect(RKH_STATE_CAST(&s2211));
703 sm_enstate_expect(RKH_STATE_CAST(&s2211));
704 sm_nenex_expect(nEnSt, nExSt);
705 sm_state_expect(RKH_STATE_CAST(&s2211));
706 sm_evtProc_expect();
707
708 rkh_sm_init((RKH_SM_T *)smTest);
709 setState(smTest, RKH_STATE_CAST(&s2211));
710 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
711
712 p = unitrazer_getLastOut();
713 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
714}
715
716void
717test_transitionCompositeToSimpleFromLowToHighLevel(void)
718{
719 UtrzProcessOut *p;
720
721 stateList_create(targetStates, 1, &s0);
722 stateList_create(entryStates, 1, &s0);
723 stateList_create(exitStates, 3, &s221, &s22, &s2);
724
725 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
726 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
727 smTest_xS22_Expect(RKH_CAST(SmTest, smTest));
728 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
729 smTest_tr33_Expect(RKH_CAST(SmTest, smTest), &evB);
730 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
731
732 setProfile(smTest, RKH_STATE_CAST(&waiting),
733 RKH_STATE_CAST(&s221), RKH_STATE_CAST(&s22),
734 targetStates, entryStates, exitStates,
735 RKH_STATE_CAST(&s0), 1, TRN_NOT_INTERNAL, INIT_STATE_MACHINE,
736 &evB, RKH_STATE_CAST(&s221));
737
738 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
739
740 p = unitrazer_getLastOut();
741 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
742}
743
744void
745test_transitionCompositeToCompositeAtEqualLevel(void)
746{
747 UtrzProcessOut *p;
748 int nExSt, nEnSt;
749 RKH_EVT_T event;
750
751 nEnSt = 2;
752 nExSt = 2;
753 event = evB;
754
755 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
756 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
757 smTest_xS3_Expect(RKH_CAST(SmTest, smTest));
758 smTest_tr41_Expect(RKH_CAST(SmTest, smTest), &event);
759 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
760 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
761 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
762
763 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
764 sm_dch_expect(event.e, RKH_STATE_CAST(&s31));
765 sm_trn_expect(RKH_STATE_CAST(&s3), RKH_STATE_CAST(&s2));
766 sm_tsState_expect(RKH_STATE_CAST(&s2));
767 sm_exstate_expect(RKH_STATE_CAST(&s31));
768 sm_exstate_expect(RKH_STATE_CAST(&s3));
769 sm_enstate_expect(RKH_STATE_CAST(&s2));
770 sm_tsState_expect(RKH_STATE_CAST(&s21));
771 sm_enstate_expect(RKH_STATE_CAST(&s21));
772 sm_nenex_expect(nEnSt, nExSt);
773 sm_state_expect(RKH_STATE_CAST(&s21));
774 sm_evtProc_expect();
775
776 rkh_sm_init((RKH_SM_T *)smTest);
777 setState(smTest, RKH_STATE_CAST(&s31));
778 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
779
780 p = unitrazer_getLastOut();
781 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
782}
783
784void
785test_transitionCompositeToCompositeFromHighToLowLevel(void)
786{
787 UtrzProcessOut *p;
788 int nExSt, nEnSt;
789 RKH_EVT_T event;
790
791 nEnSt = 4;
792 nExSt = 2;
793 event = evC;
794
795 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
796 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
797 smTest_xS3_Expect(RKH_CAST(SmTest, smTest));
798 smTest_tr42_Expect(RKH_CAST(SmTest, smTest), &event);
799 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
800 smTest_nS22_Expect(RKH_CAST(SmTest, smTest));
801 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
802 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
803 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
804 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
805
806 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
807 sm_dch_expect(event.e, RKH_STATE_CAST(&s31));
808 sm_trn_expect(RKH_STATE_CAST(&s3), RKH_STATE_CAST(&s22));
809 sm_tsState_expect(RKH_STATE_CAST(&s22));
810 sm_exstate_expect(RKH_STATE_CAST(&s31));
811 sm_exstate_expect(RKH_STATE_CAST(&s3));
812 sm_enstate_expect(RKH_STATE_CAST(&s2));
813 sm_enstate_expect(RKH_STATE_CAST(&s22));
814 sm_tsState_expect(RKH_STATE_CAST(&s221));
815 sm_enstate_expect(RKH_STATE_CAST(&s221));
816 sm_tsState_expect(RKH_STATE_CAST(&s2211));
817 sm_enstate_expect(RKH_STATE_CAST(&s2211));
818 sm_nenex_expect(nEnSt, nExSt);
819 sm_state_expect(RKH_STATE_CAST(&s2211));
820 sm_evtProc_expect();
821
822 rkh_sm_init((RKH_SM_T *)smTest);
823 setState(smTest, RKH_STATE_CAST(&s31));
824 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
825
826 p = unitrazer_getLastOut();
827 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
828}
829
830void
831test_transitionCompositeToCompositeFromLowToHighLevel(void)
832{
833 UtrzProcessOut *p;
834 int nExSt, nEnSt;
835 RKH_EVT_T event;
836
837 nEnSt = 2;
838 nExSt = 4;
839 event = evC;
840
841 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
842 smTest_xS2211_Expect(RKH_CAST(SmTest, smTest));
843 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
844 smTest_xS22_Expect(RKH_CAST(SmTest, smTest));
845 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
846 smTest_tr43_Expect(RKH_CAST(SmTest, smTest), &event);
847 smTest_nS3_Expect(RKH_CAST(SmTest, smTest));
848 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
849 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
850
851 expInitSm((RKH_SMA_T *)smTest, RKH_STATE_CAST(&waiting));
852 sm_dch_expect(event.e, RKH_STATE_CAST(&s2211));
853 sm_trn_expect(RKH_STATE_CAST(&s22), RKH_STATE_CAST(&s3));
854 sm_tsState_expect(RKH_STATE_CAST(&s3));
855 sm_exstate_expect(RKH_STATE_CAST(&s2211));
856 sm_exstate_expect(RKH_STATE_CAST(&s221));
857 sm_exstate_expect(RKH_STATE_CAST(&s22));
858 sm_exstate_expect(RKH_STATE_CAST(&s2));
859 sm_enstate_expect(RKH_STATE_CAST(&s3));
860 sm_tsState_expect(RKH_STATE_CAST(&s31));
861 sm_enstate_expect(RKH_STATE_CAST(&s31));
862 sm_nenex_expect(nEnSt, nExSt);
863 sm_state_expect(RKH_STATE_CAST(&s31));
864 sm_evtProc_expect();
865
866 rkh_sm_init((RKH_SM_T *)smTest);
867 setState(smTest, RKH_STATE_CAST(&s2211));
868 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
869
870 p = unitrazer_getLastOut();
871 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
872}
873
874void
875test_transitionInternalInSimpleState(void)
876{
877 UtrzProcessOut *p;
878
879 stateList_create(targetStates, 1, &s1);
880 stateList_create(entryStates, 0);
881 stateList_create(exitStates, 0);
882
883 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
884 smTest_tr14_Expect(RKH_CAST(SmTest, smTest), &evB);
885
886 setProfile(smTest, RKH_STATE_CAST(&waiting),
887 RKH_STATE_CAST(&s1), RKH_STATE_CAST(&s1),
888 targetStates, entryStates, exitStates,
889 RKH_STATE_CAST(&s1), 1, TRN_INTERNAL, INIT_STATE_MACHINE,
890 &evB, RKH_STATE_CAST(&s1));
891
892 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
893
894 p = unitrazer_getLastOut();
895 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
896}
897
898void
899test_transitionInternalInCompositeState(void)
900{
901 UtrzProcessOut *p;
902
903 stateList_create(targetStates, 1, &s3);
904 stateList_create(entryStates, 0);
905 stateList_create(exitStates, 0);
906
907 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
908 smTest_tr15_Expect(RKH_CAST(SmTest, smTest), &evE);
909
910 setProfile(smTest, RKH_STATE_CAST(&waiting),
911 RKH_STATE_CAST(&s31), RKH_STATE_CAST(&s3),
912 targetStates, entryStates, exitStates,
913 RKH_STATE_CAST(&s31), 1, TRN_INTERNAL, INIT_STATE_MACHINE,
914 &evE, RKH_STATE_CAST(&s31));
915
916 rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
917
918 p = unitrazer_getLastOut();
919 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
920}
921
922void
923test_transitionFails_EventNotFound(void)
924{
925 UtrzProcessOut *p;
926
927 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
928
929 expInitSm(smTest, RKH_STATE_CAST(&waiting));
930 sm_dch_expect(evE.e, RKH_STATE_CAST(&s1));
931 sm_evtNotFound_expect(E);
932
933 rkh_sm_init((RKH_SM_T *)smTest);
934 setState(smTest, RKH_STATE_CAST(&s1));
935 rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
936
937 p = unitrazer_getLastOut();
938 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
939}
940
941void
942test_transitionFails_GuardFalse(void)
943{
944 UtrzProcessOut *p;
945
946 expInitSm(smTest, RKH_STATE_CAST(&waiting));
947 sm_grdFalse_expect();
948 sm_dch_expect(evC.e, RKH_STATE_CAST(&s1));
949 sm_evtNotFound_expect(C);
950
951 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
952 smTest_falseGuard_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evC,
953 RKH_FALSE);
954
955 rkh_sm_init((RKH_SM_T *)smTest);
956 setState(smTest, RKH_STATE_CAST(&s1));
957 rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
958
959 p = unitrazer_getLastOut();
960 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
961}
962
963void
964test_transitionFails_ExceededHierarchicalLevel(void)
965{
966 UtrzProcessOut *p;
967
968 expInitSm(smTest, RKH_STATE_CAST(&waiting));
969 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
970 sm_dch_expect(evE.e, RKH_STATE_CAST(&s0));
971 sm_trn_expect(RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s22211));
972 sm_tsState_expect(RKH_STATE_CAST(&s22211));
973 sm_exHLevel_expect();
974 rkh_assert_Expect("rkhsm", 0);
975 rkh_assert_IgnoreArg_file();
976 rkh_assert_IgnoreArg_line();
977
978 rkh_sm_init((RKH_SM_T *)smTest);
979 setState(smTest, RKH_STATE_CAST(&s0));
980 rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
981
982 p = unitrazer_getLastOut();
983 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
984}
985
986void
987test_transitionMultipleEnabledTrn_FiringFirstTrueGuard(void)
988{
989 UtrzProcessOut *p;
990
991 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
992 smTest_guard4a_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evA, RKH_FALSE);
993 smTest_guard4b_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evA, RKH_TRUE);
994
995 sm_init_ignore();
996 sm_tsState_ignore();
997 sm_nenex_ignore();
998 sm_state_ignore();
999 sm_enstate_ignore();
1000 sm_ntrnact_ignore();
1001 sm_dch_ignore();
1002 sm_trn_ignore();
1003 sm_evtProc_ignore();
1004 sm_grdFalse_expect();
1005
1006 rkh_sm_init((RKH_SM_T *)smTest);
1007 setState(smTest, RKH_STATE_CAST(&s4));
1008 rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1009
1010 p = unitrazer_getLastOut();
1011 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1012}
1013
1014void
1015test_transitionMultipleEnabledTrn_FiringFirstEmptyGuard(void)
1016{
1017 UtrzProcessOut *p;
1018
1019 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1020 smTest_guard4a_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evB, RKH_FALSE);
1021 smTest_guard4b_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evB, RKH_FALSE);
1022
1023 sm_init_ignore();
1024 sm_nenex_ignore();
1025 sm_state_ignore();
1026 sm_enstate_ignore();
1027 sm_exstate_ignore();
1028 sm_ntrnact_ignore();
1029 sm_evtProc_ignore();
1030 sm_trn_ignore();
1031 sm_nenex_ignore();
1032 sm_state_ignore();
1033 sm_dch_ignore();
1034 sm_tsState_expect(RKH_STATE_CAST(&waiting));
1035 sm_grdFalse_expect();
1036 sm_grdFalse_expect();
1037 sm_tsState_expect(RKH_STATE_CAST(&s4));
1038
1039 rkh_sm_init((RKH_SM_T *)smTest);
1040 setState(smTest, RKH_STATE_CAST(&s4));
1041 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1042
1043 p = unitrazer_getLastOut();
1044 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1045}
1046
1047void
1048test_transitionDefaultTrnWithAssociatedEffect(void)
1049{
1050 UtrzProcessOut *p;
1051 int nExSt, nEnSt;
1052 RKH_EVT_T event;
1053
1054 nEnSt = 2;
1055 nExSt = 1;
1056 event = evF;
1057
1058 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1059 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1060 smTest_tr55_Expect(RKH_CAST(SmTest, smTest), &event);
1061 smTest_nS3_Expect(RKH_CAST(SmTest, smTest));
1062 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&event);
1063 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
1064
1065 expInitSm(smTest, RKH_STATE_CAST(&waiting));
1066 sm_dch_expect(event.e, RKH_STATE_CAST(&s0));
1067 sm_trn_expect(RKH_STATE_CAST(&s0), RKH_STATE_CAST(&s3));
1068 sm_tsState_expect(RKH_STATE_CAST(&s3));
1069 sm_exstate_expect(RKH_STATE_CAST(&s0));
1070 sm_enstate_expect(RKH_STATE_CAST(&s3));
1071 sm_tsState_expect(RKH_STATE_CAST(&s31));
1072 sm_enstate_expect(RKH_STATE_CAST(&s31));
1073 sm_nenex_expect(nEnSt, nExSt);
1074 sm_state_expect(RKH_STATE_CAST(&s31));
1075 sm_evtProc_expect();
1076
1077 rkh_sm_init((RKH_SM_T *)smTest);
1078 setState(smTest, RKH_STATE_CAST(&s0));
1079 rkh_sm_dispatch((RKH_SM_T *)smTest, &event);
1080
1081 p = unitrazer_getLastOut();
1082 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1083}
1084
1085void
1086test_transitionGeneratedCompletionEventBySimpleState(void)
1087{
1088 UtrzProcessOut *p;
1089
1090 stateList_create(targetStates, 1, &s5);
1091 stateList_create(entryStates, 1, &s5);
1092 stateList_create(exitStates, 2, &s21, &s2);
1093
1094 /* Expectations for transition to s5 */
1095 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1096 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1097 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1098 smTest_nS5_Expect(RKH_CAST(SmTest, smTest));
1099
1100 setProfile(smTest, RKH_STATE_CAST(&waiting),
1101 RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s2),
1102 targetStates, entryStates, exitStates,
1103 RKH_STATE_CAST(&s5), 0, TRN_NOT_INTERNAL, INIT_STATE_MACHINE,
1104 &evE, RKH_STATE_CAST(&s21));
1105
1106 /* Expectations for completion transition */
1107 stateList_create(targetStates, 1, &s4);
1108 stateList_create(entryStates, 1, &s4);
1109 stateList_create(exitStates, 1, &s5);
1110
1111 smTest_xS5_Expect(RKH_CAST(SmTest, smTest));
1112 smTest_tr61_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCompletion);
1113
1114 setProfile(smTest, RKH_STATE_CAST(&waiting),
1115 NULL, RKH_STATE_CAST(&s5),
1116 targetStates, entryStates, exitStates,
1117 RKH_STATE_CAST(&s4), 1, TRN_NOT_INTERNAL,
1118 NO_INIT_STATE_MACHINE, &evCompletion, RKH_STATE_CAST(&s5));
1119
1120 /* Exercices */
1121 rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
1122
1123 p = unitrazer_getLastOut();
1124 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1125}
1126
1127void
1128test_transitionGeneratedCompletionEventByFinalState(void)
1129{
1130 UtrzProcessOut *p;
1131
1132 stateList_create(targetStates, 1, &s2Final);
1133 stateList_create(entryStates, 1, &s2Final);
1134 stateList_create(exitStates, 1, &s21);
1135
1136 /* Expectations for transition to S2's FinalState */
1137 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1138 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1139
1140 setProfile(smTest, RKH_STATE_CAST(&waiting),
1141 RKH_STATE_CAST(&s21), RKH_STATE_CAST(&s21),
1142 targetStates, entryStates, exitStates,
1143 RKH_STATE_CAST(&s2Final), 0, TRN_NOT_INTERNAL,
1144 INIT_STATE_MACHINE, &evF, RKH_STATE_CAST(&s21));
1145
1146 /* Expectations for completion transition */
1147 stateList_create(targetStates, 1, &s4);
1148 stateList_create(entryStates, 1, &s4);
1149 stateList_create(exitStates, 2, &s2Final, &s2);
1150
1151 smTest_guardS2_ExpectAndReturn(RKH_CAST(SmTest, smTest),
1152 (RKH_EVT_T *)&evCompletion,
1153 RKH_TRUE);
1154 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1155 smTest_tr60_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCompletion);
1156
1157 setProfile(smTest, RKH_STATE_CAST(&waiting),
1158 NULL, RKH_STATE_CAST(&s2),
1159 targetStates, entryStates, exitStates,
1160 RKH_STATE_CAST(&s4), 1, TRN_NOT_INTERNAL,
1161 NO_INIT_STATE_MACHINE, &evCompletion, RKH_STATE_CAST(&s2Final));
1162
1163 /* Exercices */
1164 rkh_sm_dispatch((RKH_SM_T *)smTest, &evF);
1165
1166 p = unitrazer_getLastOut();
1167 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1168}
1169
1170void
1171test_transitionSyncDispatchingToStateMachine(void)
1172{
1173 TEST_IGNORE();
1174}
1175
1176void
1177test_transitionToStateMachineFinalState(void)
1178{
1179 UtrzProcessOut *p;
1180
1181 stateList_create(targetStates, 1, &SmTest_Final);
1182 stateList_create(entryStates, 1, &SmTest_Final);
1183 stateList_create(exitStates, 1, &waiting);
1184
1185 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1186
1187 setProfile(smTest, RKH_STATE_CAST(&waiting),
1188 RKH_STATE_CAST(&waiting), RKH_STATE_CAST(&waiting),
1189 targetStates, entryStates, exitStates,
1190 RKH_STATE_CAST(&SmTest_Final), 1, TRN_NOT_INTERNAL,
1191 INIT_STATE_MACHINE,
1192 &evB, RKH_STATE_CAST(&waiting));
1193
1194 rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1195
1196 p = unitrazer_getLastOut();
1197 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1198}
1199
1210void
1211test_trnWoutUnitrazerFirstStateAfterInit(void)
1212{
1213 setUpWoutUnitrazer();
1214
1215 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1216 expectedState = RKH_STATE_CAST(&waiting);
1217
1218 rkh_sm_init((RKH_SM_T *)smTest);
1219
1220 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1221}
1222
1223void
1224test_trnWoutUnitrazerSimpleToSimpleAtEqualLevel(void)
1225{
1226 setUpWoutUnitrazer();
1227
1228 expectedState = RKH_STATE_CAST(&s1);
1229
1230 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1231 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1232 smTest_tr11_Expect(RKH_CAST(SmTest, smTest), &evA);
1233 smTest_nS1_Expect(RKH_CAST(SmTest, smTest));
1234 setProfileWoutUnitrazer(smTest,
1235 RKH_STATE_CAST(&s0),
1236 RKH_STATE_CAST(&s0),
1237 expectedState,
1238 INIT_STATE_MACHINE);
1239
1240 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1241
1242 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1243 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1244}
1245
1246void
1247test_trnWoutUnitrazerSimpleToSimpleFromHighToLowLevel(void)
1248{
1249 setUpWoutUnitrazer();
1250
1251 expectedState = RKH_STATE_CAST(&s21);
1252
1253 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1254 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1255 smTest_tr12_Expect(RKH_CAST(SmTest, smTest), &evB);
1256 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
1257 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
1258 setProfileWoutUnitrazer(smTest,
1259 RKH_STATE_CAST(&s0),
1260 RKH_STATE_CAST(&s0),
1261 expectedState,
1262 INIT_STATE_MACHINE);
1263
1264 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1265
1266 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1267 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1268}
1269
1270void
1271test_trnWoutUnitrazerSimpleToSimpleFromLowToHighLevel(void)
1272{
1273 setUpWoutUnitrazer();
1274
1275 expectedState = RKH_STATE_CAST(&s0);
1276
1277 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1278 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1279 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1280 smTest_tr13_Expect(RKH_CAST(SmTest, smTest), &evB);
1281 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
1282 setProfileWoutUnitrazer(smTest,
1283 RKH_STATE_CAST(&s21),
1284 RKH_STATE_CAST(&s21),
1285 expectedState,
1286 INIT_STATE_MACHINE);
1287
1288 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1289
1290 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1291 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1292}
1293
1294void
1295test_trnWoutUnitrazerSimpleToCompositeAtEqualLevel(void)
1296{
1297 setUpWoutUnitrazer();
1298
1299 expectedState = RKH_STATE_CAST(&s21);
1300
1301 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1302 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1303 smTest_tr21_Expect(RKH_CAST(SmTest, smTest), &evC);
1304 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
1305 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), &evC);
1306 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
1307 setProfileWoutUnitrazer(smTest,
1308 RKH_STATE_CAST(&s0),
1309 RKH_STATE_CAST(&s0),
1310 expectedState,
1311 INIT_STATE_MACHINE);
1312
1313 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1314
1315 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1316 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1317}
1318
1319void
1320test_trnWoutUnitrazerSimpleToCompositeFromHighToLowLevel(void)
1321{
1322 setUpWoutUnitrazer();
1323
1324 expectedState = RKH_STATE_CAST(&s2211);
1325
1326 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1327 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1328 smTest_tr22_Expect(RKH_CAST(SmTest, smTest), &evD);
1329 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
1330 smTest_nS22_Expect(RKH_CAST(SmTest, smTest));
1331 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), &evD);
1332 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
1333 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), &evD);
1334 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
1335 setProfileWoutUnitrazer(smTest,
1336 RKH_STATE_CAST(&s0),
1337 RKH_STATE_CAST(&s0),
1338 expectedState,
1339 INIT_STATE_MACHINE);
1340
1341 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
1342
1343 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1344 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1345}
1346
1347void
1348test_trnWoutUnitrazerSimpleToCompositeFromLowToHighLevel(void)
1349{
1350 setUpWoutUnitrazer();
1351
1352 expectedState = RKH_STATE_CAST(&s21);
1353
1354 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1355 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1356 smTest_tr23_Expect(RKH_CAST(SmTest, smTest), &evC);
1357 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), &evC);
1358 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
1359 setProfileWoutUnitrazer(smTest,
1360 RKH_STATE_CAST(&s21),
1361 RKH_STATE_CAST(&s21),
1362 expectedState,
1363 INIT_STATE_MACHINE);
1364
1365 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1366
1367 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1368 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1369}
1370
1371void
1372test_trnWoutUnitrazerCompositeToSimpleAtEqualLevel(void)
1373{
1374 setUpWoutUnitrazer();
1375
1376 expectedState = RKH_STATE_CAST(&s0);
1377
1378 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1379 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1380 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1381 smTest_tr31_Expect(RKH_CAST(SmTest, smTest), &evA);
1382 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
1383 setProfileWoutUnitrazer(smTest,
1384 RKH_STATE_CAST(&s21),
1385 RKH_STATE_CAST(&s2),
1386 expectedState,
1387 INIT_STATE_MACHINE);
1388
1389 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1390
1391 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1392 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1393}
1394
1395void
1396test_trnWoutUnitrazerCompositeToSimpleFromHighToLowLevel(void)
1397{
1398 setUpWoutUnitrazer();
1399
1400 expectedState = RKH_STATE_CAST(&s21);
1401
1402 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1403 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1404 smTest_tr32_Expect(RKH_CAST(SmTest, smTest), &evD);
1405 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
1406 setProfileWoutUnitrazer(smTest,
1407 RKH_STATE_CAST(&s21),
1408 RKH_STATE_CAST(&s2),
1409 expectedState,
1410 INIT_STATE_MACHINE);
1411
1412 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
1413
1414 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1415 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1416}
1417
1418void
1419test_trnWoutUnitrazerLoopSimpleStateOnTop(void)
1420{
1421 setUpWoutUnitrazer();
1422
1423 expectedState = RKH_STATE_CAST(&s1);
1424
1425 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1426 smTest_xS1_Expect(RKH_CAST(SmTest, smTest));
1427 smTest_tr53_Expect(RKH_CAST(SmTest, smTest), &evA);
1428 smTest_nS1_Expect(RKH_CAST(SmTest, smTest));
1429 setProfileWoutUnitrazer(smTest,
1430 RKH_STATE_CAST(&s1),
1431 RKH_STATE_CAST(&s1),
1432 expectedState,
1433 INIT_STATE_MACHINE);
1434
1435 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1436
1437 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1438 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1439}
1440
1441void
1442test_trnWoutUnitrazerLoopNestedSimpleState(void)
1443{
1444 setUpWoutUnitrazer();
1445
1446 expectedState = RKH_STATE_CAST(&s31);
1447
1448 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1449 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
1450 smTest_tr52_Expect(RKH_CAST(SmTest, smTest), &evD);
1451 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
1452 setProfileWoutUnitrazer(smTest,
1453 RKH_STATE_CAST(&s31),
1454 RKH_STATE_CAST(&s31),
1455 expectedState,
1456 INIT_STATE_MACHINE);
1457
1458 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
1459
1460 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1461 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1462}
1463
1464void
1465test_trnWoutUnitrazerLoopCompositeStateOnTop(void)
1466{
1467 setUpWoutUnitrazer();
1468
1469 expectedState = RKH_STATE_CAST(&s31);
1470
1471 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1472 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
1473 smTest_tr51_Expect(RKH_CAST(SmTest, smTest), &evA);
1474 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), &evA);
1475 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
1476 setProfileWoutUnitrazer(smTest,
1477 RKH_STATE_CAST(&s31),
1478 RKH_STATE_CAST(&s3),
1479 expectedState,
1480 INIT_STATE_MACHINE);
1481
1482 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1483
1484 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1485 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1486}
1487
1488void
1489test_trnWoutUnitrazerLoopNestedCompositeState(void)
1490{
1491 setUpWoutUnitrazer();
1492
1493 expectedState = RKH_STATE_CAST(&s2211);
1494
1495 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1496 smTest_xS2211_Expect(RKH_CAST(SmTest, smTest));
1497 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
1498 smTest_tr54_Expect(RKH_CAST(SmTest, smTest), &evD);
1499 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), &evD);
1500 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
1501 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), &evD);
1502 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
1503 setProfileWoutUnitrazer(smTest,
1504 RKH_STATE_CAST(&s2211),
1505 RKH_STATE_CAST(&s22),
1506 expectedState,
1507 INIT_STATE_MACHINE);
1508
1509 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
1510
1511 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1512 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1513}
1514
1515void
1516test_trnWoutUnitrazerCompositeToSimpleFromLowToHighLevel(void)
1517{
1518 setUpWoutUnitrazer();
1519
1520 expectedState = RKH_STATE_CAST(&s0);
1521
1522 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1523 smTest_xS2211_Expect(RKH_CAST(SmTest, smTest));
1524 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
1525 smTest_xS22_Expect(RKH_CAST(SmTest, smTest));
1526 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1527 smTest_tr33_Expect(RKH_CAST(SmTest, smTest), &evB);
1528 smTest_nS0_Expect(RKH_CAST(SmTest, smTest));
1529 setProfileWoutUnitrazer(smTest,
1530 RKH_STATE_CAST(&s2211),
1531 RKH_STATE_CAST(&s22),
1532 expectedState,
1533 INIT_STATE_MACHINE);
1534
1535 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1536
1537 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1538 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1539}
1540
1541void
1542test_trnWoutUnitrazerCompositeToCompositeAtEqualLevel(void)
1543{
1544 setUpWoutUnitrazer();
1545
1546 expectedState = RKH_STATE_CAST(&s21);
1547
1548 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1549 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
1550 smTest_xS3_Expect(RKH_CAST(SmTest, smTest));
1551 smTest_tr41_Expect(RKH_CAST(SmTest, smTest), &evB);
1552 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
1553 smTest_iS2_Expect(RKH_CAST(SmTest, smTest), &evB);
1554 smTest_nS21_Expect(RKH_CAST(SmTest, smTest));
1555 setProfileWoutUnitrazer(smTest,
1556 RKH_STATE_CAST(&s31),
1557 RKH_STATE_CAST(&s3),
1558 expectedState,
1559 INIT_STATE_MACHINE);
1560
1561 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1562
1563 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1564 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1565}
1566
1567void
1568test_trnWoutUnitrazerCompositeToCompositeFromHighToLowLevel(void)
1569{
1570 setUpWoutUnitrazer();
1571
1572 expectedState = RKH_STATE_CAST(&s2211);
1573
1574 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1575 smTest_xS31_Expect(RKH_CAST(SmTest, smTest));
1576 smTest_xS3_Expect(RKH_CAST(SmTest, smTest));
1577 smTest_tr42_Expect(RKH_CAST(SmTest, smTest), &evC);
1578 smTest_nS2_Expect(RKH_CAST(SmTest, smTest));
1579 smTest_nS22_Expect(RKH_CAST(SmTest, smTest));
1580 smTest_iS22_Expect(RKH_CAST(SmTest, smTest), &evC);
1581 smTest_nS221_Expect(RKH_CAST(SmTest, smTest));
1582 smTest_iS221_Expect(RKH_CAST(SmTest, smTest), &evC);
1583 smTest_nS2211_Expect(RKH_CAST(SmTest, smTest));
1584 setProfileWoutUnitrazer(smTest,
1585 RKH_STATE_CAST(&s31),
1586 RKH_STATE_CAST(&s3),
1587 expectedState,
1588 INIT_STATE_MACHINE);
1589
1590 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1591
1592 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1593 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1594}
1595
1596void
1597test_trnWoutUnitrazerCompositeToCompositeFromLowToHighLevel(void)
1598{
1599 setUpWoutUnitrazer();
1600
1601 expectedState = RKH_STATE_CAST(&s31);
1602
1603 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1604 smTest_xS2211_Expect(RKH_CAST(SmTest, smTest));
1605 smTest_xS221_Expect(RKH_CAST(SmTest, smTest));
1606 smTest_xS22_Expect(RKH_CAST(SmTest, smTest));
1607 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1608 smTest_tr43_Expect(RKH_CAST(SmTest, smTest), &evC);
1609 smTest_nS3_Expect(RKH_CAST(SmTest, smTest));
1610 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), &evC);
1611 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
1612 setProfileWoutUnitrazer(smTest,
1613 RKH_STATE_CAST(&s2211),
1614 RKH_STATE_CAST(&s3),
1615 expectedState,
1616 INIT_STATE_MACHINE);
1617
1618 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1619
1620 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1621 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1622}
1623
1624void
1625test_trnWoutUnitrazerInternalInSimpleState(void)
1626{
1627 setUpWoutUnitrazer();
1628
1629 expectedState = RKH_STATE_CAST(&s1);
1630
1631 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1632 smTest_tr14_Expect(RKH_CAST(SmTest, smTest), &evB);
1633 setProfileWoutUnitrazer(smTest,
1634 RKH_STATE_CAST(&s1),
1635 RKH_STATE_CAST(&s1),
1636 expectedState,
1637 INIT_STATE_MACHINE);
1638
1639 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1640
1641 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1642 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1643}
1644
1645void
1646test_trnWoutUnitrazerInternalInCompositeState(void)
1647{
1648 setUpWoutUnitrazer();
1649
1650 expectedState = RKH_STATE_CAST(&s31);
1651
1652 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1653 smTest_tr15_Expect(RKH_CAST(SmTest, smTest), &evE);
1654 setProfileWoutUnitrazer(smTest,
1655 RKH_STATE_CAST(&s31),
1656 RKH_STATE_CAST(&s3),
1657 expectedState,
1658 INIT_STATE_MACHINE);
1659
1660 rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
1661
1662 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1663}
1664
1665void
1666test_trnWoutUnitrazerFails_EventNotFound(void)
1667{
1668 setUpWoutUnitrazer();
1669
1670 expectedState = RKH_STATE_CAST(&s1);
1671
1672 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1673 setProfileWoutUnitrazer(smTest,
1674 RKH_STATE_CAST(&s1),
1675 RKH_STATE_CAST(&s1),
1676 expectedState,
1677 INIT_STATE_MACHINE);
1678
1679 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
1680
1681 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1682 TEST_ASSERT_EQUAL(RKH_EVT_NFOUND, result);
1683}
1684
1685void
1686test_trnWoutUnitrazerFails_GuardFalseOnInternalTrn(void)
1687{
1688 setUpWoutUnitrazer();
1689
1690 expectedState = RKH_STATE_CAST(&s1);
1691
1692 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1693 smTest_falseGuard_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evC,
1694 RKH_FALSE);
1695 setProfileWoutUnitrazer(smTest,
1696 RKH_STATE_CAST(&s1),
1697 RKH_STATE_CAST(&s1),
1698 expectedState,
1699 INIT_STATE_MACHINE);
1700
1701 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1702
1703 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1704 TEST_ASSERT_EQUAL(RKH_EVT_NFOUND, result);
1705}
1706
1707void
1708test_trnWoutUnitrazerFails_GuardFalseOnExternalTrn(void)
1709{
1710 setUpWoutUnitrazer();
1711
1712 expectedState = RKH_STATE_CAST(&s1);
1713
1714 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1715 smTest_falseGuard_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evD,
1716 RKH_FALSE);
1717 setProfileWoutUnitrazer(smTest,
1718 RKH_STATE_CAST(&s1),
1719 RKH_STATE_CAST(&s1),
1720 expectedState,
1721 INIT_STATE_MACHINE);
1722
1723 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evD);
1724
1725 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1726 TEST_ASSERT_EQUAL(RKH_EVT_NFOUND, result);
1727}
1728
1729void
1730test_trnWoutUnitrazerFails_ExceededHierarchicalLevel(void)
1731{
1732 setUpWoutUnitrazer();
1733
1734 expectedState = RKH_STATE_CAST(&s0);
1735
1736 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1737 setProfileWoutUnitrazer(smTest,
1738 RKH_STATE_CAST(&s0),
1739 RKH_STATE_CAST(&s0),
1740 expectedState,
1741 INIT_STATE_MACHINE);
1742 rkh_assert_Expect("rkhsm", 0);
1743 rkh_assert_IgnoreArg_file();
1744 rkh_assert_IgnoreArg_line();
1745
1746 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
1747
1748 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1749 TEST_ASSERT_EQUAL(RKH_EX_HLEVEL, result);
1750}
1751
1752void
1753test_trnWoutUnitrazerMultipleEnabledTrn_FiringFirstTrueGuard(void)
1754{
1755 setUpWoutUnitrazer();
1756
1757 expectedState = RKH_STATE_CAST(&s4);
1758
1759 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1760 smTest_guard4a_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evA, RKH_FALSE);
1761 smTest_guard4b_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evA, RKH_TRUE);
1762 setProfileWoutUnitrazer(smTest,
1763 RKH_STATE_CAST(&s4),
1764 RKH_STATE_CAST(&s4),
1765 expectedState,
1766 INIT_STATE_MACHINE);
1767
1768 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evA);
1769
1770 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1771 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1772}
1773
1774void
1775test_trnWoutUnitrazerMultipleEnabledTrn_FiringFirstEmptyGuard(void)
1776{
1777 setUpWoutUnitrazer();
1778
1779 expectedState = RKH_STATE_CAST(&s4);
1780
1781 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1782 smTest_guard4a_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evB, RKH_FALSE);
1783 smTest_guard4b_ExpectAndReturn(RKH_CAST(SmTest, smTest), &evB, RKH_FALSE);
1784 setProfileWoutUnitrazer(smTest,
1785 RKH_STATE_CAST(&s4),
1786 RKH_STATE_CAST(&s4),
1787 expectedState,
1788 INIT_STATE_MACHINE);
1789
1790 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evB);
1791
1792 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1793 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1794}
1795
1796void
1797test_trnWoutUnitrazerDefaultTrnWithAssociatedEffect(void)
1798{
1799 setUpWoutUnitrazer();
1800
1801 expectedState = RKH_STATE_CAST(&s31);
1802
1803 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1804 smTest_xS0_Expect(RKH_CAST(SmTest, smTest));
1805 smTest_tr55_Expect(RKH_CAST(SmTest, smTest), &evF);
1806 smTest_nS3_Expect(RKH_CAST(SmTest, smTest));
1807 smTest_iS3_Expect(RKH_CAST(SmTest, smTest), &evF);
1808 smTest_nS31_Expect(RKH_CAST(SmTest, smTest));
1809 setProfileWoutUnitrazer(smTest,
1810 RKH_STATE_CAST(&s0),
1811 RKH_STATE_CAST(&s0),
1812 expectedState,
1813 INIT_STATE_MACHINE);
1814
1815 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evF);
1816
1817 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1818 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1819}
1820
1821void
1822test_trnWoutUnitrazerGeneratedCompletionEventBySimpleState(void)
1823{
1824 setUpWoutUnitrazer();
1825
1826 expectedState = RKH_STATE_CAST(&s4);
1827
1828 /* Expectations for transition to s5 */
1829 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1830 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1831 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1832 smTest_nS5_Expect(RKH_CAST(SmTest, smTest));
1833 /* Expectations for completion transition */
1834 smTest_xS5_Expect(RKH_CAST(SmTest, smTest));
1835 smTest_tr61_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCompletion);
1836 setProfileWoutUnitrazer(smTest,
1837 RKH_STATE_CAST(&s21),
1838 RKH_STATE_CAST(&s2),
1839 expectedState,
1840 INIT_STATE_MACHINE);
1841
1842 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evE);
1843
1844 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1845 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1846}
1847
1848void
1849test_trnWoutUnitrazerGeneratedCompletionEventByFinalState(void)
1850{
1851 setUpWoutUnitrazer();
1852
1853 expectedState = RKH_STATE_CAST(&s4);
1854
1855 /* Expectations for transition to S2's FinalState */
1856 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1857 smTest_xS21_Expect(RKH_CAST(SmTest, smTest));
1858 /* Expectations for completion transition */
1859 smTest_guardS2_ExpectAndReturn(RKH_CAST(SmTest, smTest),
1860 (RKH_EVT_T *)&evCompletion,
1861 RKH_TRUE);
1862 smTest_xS2_Expect(RKH_CAST(SmTest, smTest));
1863 smTest_tr60_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCompletion);
1864 setProfileWoutUnitrazer(smTest,
1865 RKH_STATE_CAST(&s21),
1866 RKH_STATE_CAST(&s21),
1867 expectedState,
1868 INIT_STATE_MACHINE);
1869
1870 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evF);
1871
1872 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1873 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1874}
1875
1876void
1877test_trnWoutUnitrazerSyncDispatchingToStateMachine(void)
1878{
1879 TEST_IGNORE();
1880
1881 setUpWoutUnitrazer();
1882}
1883
1884void
1885test_trnWoutUnitrazerPropagateAnEvent(void)
1886{
1887 setUpWoutUnitrazer();
1888
1889 expectedState = RKH_STATE_CAST(&waiting);
1890
1891 smTest_init_Expect(RKH_CAST(SmTest, smTest), (RKH_EVT_T *)&evCreation);
1892 smTest_tr16_Expect(RKH_CAST(SmTest, smTest), &evC);
1893 smTest_tr16_StubWithCallback(MockEffectCallback0);
1894 smTest_tr17_Expect(RKH_CAST(SmTest, smTest), &evD);
1895 smTest_tr17_StubWithCallback(MockEffectCallback1);
1896 setProfileWoutUnitrazer(smTest,
1897 RKH_STATE_CAST(&waiting),
1898 RKH_STATE_CAST(&waiting),
1899 expectedState,
1900 INIT_STATE_MACHINE);
1901
1902 result = rkh_sm_dispatch((RKH_SM_T *)smTest, &evC);
1903
1904 TEST_ASSERT_TRUE(expectedState == getState(smTest));
1905 TEST_ASSERT_EQUAL(RKH_EVT_PROC, result);
1906}
1907
1916void
1917test_pseudostateConditionalFirstStateAfterInit(void)
1918{
1919 UtrzProcessOut *p;
1920
1921 sm_init_expect(RKH_STATE_CAST(&smPCT_waiting));
1922 sm_trn_expect(RKH_STATE_CAST(&smPCT_waiting),
1923 RKH_STATE_CAST(&smPCT_waiting));
1924 sm_tsState_expect(RKH_STATE_CAST(&smPCT_waiting));
1925 sm_enstate_expect(RKH_STATE_CAST(&smPCT_waiting));
1926 sm_nenex_expect(1, 0);
1927 sm_state_expect(RKH_STATE_CAST(&smPCT_waiting));
1928 sm_evtProc_expect();
1929
1930 rkh_sm_init((RKH_SM_T *)smPseudoConditionalTest);
1931
1932 p = unitrazer_getLastOut();
1933 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1934}
1935
1936void
1937test_pseudostateConditionalTrnToChoiceWithTrueCondition(void)
1938{
1939 UtrzProcessOut *p;
1940 SmPseudoConditionalTest *me = RKH_CAST(SmPseudoConditionalTest,
1941 smPseudoConditionalTest);
1942
1943 /* Expect call actions */
1944 smPCT_setCondition_Expect(
1945 RKH_CAST(SmPseudoConditionalTest, me), &evA);
1946 smPCT_onEventA_ExpectAndReturn(
1947 RKH_CAST(SmPseudoConditionalTest, me),
1948 &evA, RKH_TRUE);
1949 smPCT_tr1_Expect(
1950 RKH_CAST(SmPseudoConditionalTest, me), &evA);
1951 /* Expect init state machine */
1952 expInitSm((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_waiting));
1953 /* Expect first transition segment */
1954 sm_dch_expect(evA.e, RKH_STATE_CAST(&smPCT_s0));
1955 sm_trn_expect(RKH_STATE_CAST(&smPCT_s0), RKH_STATE_CAST(&smPCT_choice1));
1956 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice1));
1957 //sm_ntrnact_expect(1, 1);
1958 /* Expect target state of last (second) transition */
1959 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s1));
1960 /* Expect solve compoused transition */
1961 sm_exstate_expect(RKH_STATE_CAST(&smPCT_s0));
1962 //sm_ntrnact_expect(1, 2);
1963 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s1));
1964 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s11));
1965 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s11));
1966 sm_nenex_expect(2, 1);
1967 /* Expect main target state */
1968 sm_state_expect(RKH_STATE_CAST(&smPCT_s11));
1969 sm_evtProc_expect();
1970
1971 /* Initialize and set state */
1972 rkh_sm_init((RKH_SM_T *)me);
1973 setState((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_s0));
1974
1975 rkh_sm_dispatch((RKH_SM_T *)me, &evA);
1976
1977 p = unitrazer_getLastOut();
1978 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
1979}
1980
1981void
1982test_pseudostateConditionalTrnToChoiceWithFalseCondition(void)
1983{
1984 UtrzProcessOut *p;
1985 SmPseudoConditionalTest *me = RKH_CAST(SmPseudoConditionalTest,
1986 smPseudoConditionalTest);
1987
1988 /* Expect call actions */
1989 smPCT_setCondition_Expect(
1990 RKH_CAST(SmPseudoConditionalTest, me), &evB);
1991 smPCT_onEventA_ExpectAndReturn(
1992 RKH_CAST(SmPseudoConditionalTest, me),
1993 &evB, RKH_FALSE);
1994 smPCT_onEventD_ExpectAndReturn(
1995 RKH_CAST(SmPseudoConditionalTest, me),
1996 &evB, RKH_FALSE);
1997 smPCT_tr2_Expect(
1998 RKH_CAST(SmPseudoConditionalTest, me), &evB);
1999 /* Expect init state machine */
2000 expInitSm((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_waiting));
2001 /* Expect first transition segment */
2002 sm_dch_expect(evB.e, RKH_STATE_CAST(&smPCT_s0));
2003 sm_trn_expect(RKH_STATE_CAST(&smPCT_s0), RKH_STATE_CAST(&smPCT_choice1));
2004 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice1));
2005 //sm_ntrnact_expect(1, 1);
2006 /* Expect target state of last (second) transition */
2007 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s12));
2008 /* Expect solve compoused transition */
2009 sm_exstate_expect(RKH_STATE_CAST(&smPCT_s0));
2010 //sm_ntrnact_expect(1, 2);
2011 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s1));
2012 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s12));
2013 sm_nenex_expect(2, 1);
2014 /* Expect main target state */
2015 sm_state_expect(RKH_STATE_CAST(&smPCT_s12));
2016 sm_evtProc_expect();
2017 /* Initialize and set state */
2018 rkh_sm_init((RKH_SM_T *)me);
2019 setState((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_s0));
2020
2021 rkh_sm_dispatch((RKH_SM_T *)me, &evB);
2022
2023 p = unitrazer_getLastOut();
2024 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2025}
2026
2027void
2028test_pseudostateConditionalTrnToChoiceWithoutElse(void)
2029{
2030 UtrzProcessOut *p;
2031 SmPseudoConditionalTest *me = RKH_CAST(SmPseudoConditionalTest,
2032 smPseudoConditionalTest);
2033
2034 /* Expect call actions */
2035 smPCT_onEventA_ExpectAndReturn(
2036 RKH_CAST(SmPseudoConditionalTest, me),
2037 &evC, RKH_FALSE);
2038 /* Expect init state machine */
2039 expInitSm((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_waiting));
2040 /* Expect first transition segment */
2041 sm_dch_expect(evC.e, RKH_STATE_CAST(&smPCT_s0));
2042 sm_trn_expect(RKH_STATE_CAST(&smPCT_s0), RKH_STATE_CAST(&smPCT_choice2));
2043 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice2));
2044 //sm_ntrnact_expect(0, 1);
2045 sm_cndNotFound_expect();
2046 /* Initialize and set state */
2047 rkh_sm_init((RKH_SM_T *)me);
2048 setState((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_s0));
2049
2050 rkh_sm_dispatch((RKH_SM_T *)me, &evC);
2051
2052 p = unitrazer_getLastOut();
2053 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2054}
2055
2056void
2057test_pseudostateConditionalTrnToChoiceReturnToSource(void)
2058{
2059 UtrzProcessOut *p;
2060 SmPseudoConditionalTest *me = RKH_CAST(SmPseudoConditionalTest,
2061 smPseudoConditionalTest);
2062
2063 /* Expect call actions */
2064 smPCT_onEventA_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2065 &evD, RKH_FALSE);
2066 smPCT_onEventD_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2067 &evD, RKH_TRUE);
2068 smPCT_tr4_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evD);
2069 /* Expect init state machine */
2070 expInitSm((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_waiting));
2071 /* Expect first transition segment */
2072 sm_dch_expect(evD.e, RKH_STATE_CAST(&smPCT_s0));
2073 sm_trn_expect(RKH_STATE_CAST(&smPCT_s0), RKH_STATE_CAST(&smPCT_choice1));
2074 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice1));
2075 //sm_ntrnact_expect(0, 1);
2076 /* Expect target state of last (second) transition */
2077 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s0));
2078 /* Expect solve compoused transition */
2079 sm_exstate_expect(RKH_STATE_CAST(&smPCT_s0));
2080 //sm_ntrnact_expect(1, 2);
2081 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s0));
2082 sm_nenex_expect(1, 1);
2083 /* Expect main target state */
2084 sm_state_expect(RKH_STATE_CAST(&smPCT_s0));
2085 sm_evtProc_expect();
2086 /* Initialize and set state */
2087 rkh_sm_init((RKH_SM_T *)me);
2088 setState((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_s0));
2089
2090 rkh_sm_dispatch((RKH_SM_T *)me, &evD);
2091
2092 p = unitrazer_getLastOut();
2093 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2094}
2095
2096void
2097test_pseudostateConditionalFailsTrnSegmentsExceeded(void)
2098{
2099 UtrzProcessOut *p;
2100 SmPseudoConditionalTest *me = RKH_CAST(SmPseudoConditionalTest,
2101 smPseudoConditionalTest);
2102
2103 /* Expect call actions */
2104 smPCT_tr1_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evE);
2105 smPCT_guardTrue_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2106 &evE, RKH_TRUE);
2107 smPCT_tr1_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evE);
2108 smPCT_guardTrue_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2109 &evE, RKH_TRUE);
2110 smPCT_tr1_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evE);
2111 smPCT_guardTrue_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2112 &evE, RKH_TRUE);
2113 smPCT_tr1_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evE);
2114 smPCT_guardTrue_ExpectAndReturn(RKH_CAST(SmPseudoConditionalTest, me),
2115 &evE, RKH_TRUE);
2116 smPCT_tr1_Expect(RKH_CAST(SmPseudoConditionalTest, me), &evE);
2117 /* Expect init state machine */
2118 expInitSm((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_waiting));
2119 /* Expect first transition segment */
2120 sm_dch_expect(evE.e, RKH_STATE_CAST(&smPCT_s0));
2121 sm_trn_expect(RKH_STATE_CAST(&smPCT_s0), RKH_STATE_CAST(&smPCT_choice3));
2122 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice3));
2123 //sm_ntrnact_expect(1, 1);
2124 /* Expect target state of next transition */
2125 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice4));
2126 //sm_ntrnact_expect(1, 2);
2127 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice5));
2128 //sm_ntrnact_expect(1, 3);
2129 sm_tsState_expect(RKH_STATE_CAST(&smPCT_choice6));
2130 //sm_ntrnact_expect(1, 4);
2131 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s1));
2132 /* Expect solve compoused transition */
2133 sm_exstate_expect(RKH_STATE_CAST(&smPCT_s0));
2134 //sm_ntrnact_expect(1, 5);
2135 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s1));
2136 sm_tsState_expect(RKH_STATE_CAST(&smPCT_s11));
2137 sm_enstate_expect(RKH_STATE_CAST(&smPCT_s11));
2138 sm_nenex_expect(2, 1);
2139 /* Expect main target state */
2140 sm_state_expect(RKH_STATE_CAST(&smPCT_s11));
2141 sm_evtProc_expect();
2142 /* Initialize and set state */
2143 rkh_sm_init((RKH_SM_T *)me);
2144 setState((RKH_SMA_T *)me, RKH_STATE_CAST(&smPCT_s0));
2145
2146 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2147
2148 p = unitrazer_getLastOut();
2149 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2150}
2160void
2161test_pseudostateFirstStateAfterInit(void)
2162{
2163 UtrzProcessOut *p;
2164
2165 sm_init_expect(RKH_STATE_CAST(&smPT_waiting));
2166 sm_trn_expect(RKH_STATE_CAST(&smPT_waiting),
2167 RKH_STATE_CAST(&smPT_waiting));
2168 sm_tsState_expect(RKH_STATE_CAST(&smPT_waiting));
2169 sm_enstate_expect(RKH_STATE_CAST(&smPT_waiting));
2170 sm_nenex_expect(1, 0);
2171 sm_state_expect(RKH_STATE_CAST(&smPT_waiting));
2172 sm_evtProc_expect();
2173
2174 rkh_sm_init((RKH_SM_T *)smPseudoTest);
2175
2176 p = unitrazer_getLastOut();
2177 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2178}
2179
2180void
2181test_pseudostateTrnToEmptyShallowHistoryWithoutDefaultTrn(void)
2182{
2183 UtrzProcessOut *p;
2184 int nExSt, nEnSt;
2185 RKH_EVT_T event;
2186
2187 nEnSt = 2;
2188 nExSt = 1;
2189 event = evB;
2190 expInitSm((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_waiting));
2191 sm_dch_expect(event.e, RKH_STATE_CAST(&smPT_s0));
2192 sm_trn_expect(RKH_STATE_CAST(&smPT_s0), RKH_STATE_CAST(&smPT_s1Hist));
2193 sm_tsState_expect(RKH_STATE_CAST(&smPT_s1Hist));
2194 sm_tsState_expect(RKH_STATE_CAST(&smPT_s1));
2195 sm_exstate_expect(RKH_STATE_CAST(&smPT_s0));
2196 sm_enstate_expect(RKH_STATE_CAST(&smPT_s1));
2197 sm_tsState_expect(RKH_STATE_CAST(&smPT_s11));
2198 sm_enstate_expect(RKH_STATE_CAST(&smPT_s11));
2199 sm_nenex_expect(nEnSt, nExSt);
2200 sm_state_expect(RKH_STATE_CAST(&smPT_s11));
2201 sm_evtProc_expect();
2202
2203 rkh_sm_init((RKH_SM_T *)smPseudoTest);
2204 setState((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_s0));
2205 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &event);
2206
2207 p = unitrazer_getLastOut();
2208 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2209}
2210
2211void
2212test_pseudostateTrnToLoadedShallowHistoryWithoutDefaultTrn(void)
2213{
2214 UtrzProcessOut *p;
2215 int nExSt, nEnSt;
2216 RKH_EVT_T event;
2217
2218 nEnSt = 3;
2219 nExSt = 1;
2220 event = evB;
2221 expInitSm((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_waiting));
2222 sm_dch_expect(event.e, RKH_STATE_CAST(&smPT_s0));
2223 sm_trn_expect(RKH_STATE_CAST(&smPT_s0), RKH_STATE_CAST(&smPT_s1Hist));
2224 sm_tsState_expect(RKH_STATE_CAST(&smPT_s1Hist));
2225 sm_tsState_expect(RKH_STATE_CAST(&smPT_s12));
2226 sm_exstate_expect(RKH_STATE_CAST(&smPT_s0));
2227 sm_enstate_expect(RKH_STATE_CAST(&smPT_s1));
2228 sm_enstate_expect(RKH_STATE_CAST(&smPT_s12));
2229 sm_tsState_expect(RKH_STATE_CAST(&smPT_s121));
2230 sm_enstate_expect(RKH_STATE_CAST(&smPT_s121));
2231 sm_nenex_expect(nEnSt, nExSt);
2232 sm_state_expect(RKH_STATE_CAST(&smPT_s121));
2233 sm_evtProc_expect();
2234
2235 rkh_sm_init((RKH_SM_T *)smPseudoTest);
2236 setState((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_s0));
2237 setHistory(&smPT_s1Hist, RKH_STATE_CAST(&smPT_s12));
2238 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &event);
2239
2240 p = unitrazer_getLastOut();
2241 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2242}
2243
2244void
2245test_pseudostateExitFromCompositeWithLoadedShallowHistory(void)
2246{
2247 UtrzProcessOut *p;
2248 const RKH_ST_T *state;
2249
2250 stateList_create(targetStates, 1, &smPT_s0);
2251 stateList_create(exitStates, 3, &smPT_s121, &smPT_s12, &smPT_s1);
2252 stateList_create(entryStates, 1, &smPT_s0);
2253 setProfile(smPseudoTest, RKH_STATE_CAST(&smPT_waiting),
2254 RKH_STATE_CAST(&smPT_s121),
2255 RKH_STATE_CAST(&smPT_s1), targetStates,
2256 entryStates, exitStates,
2257 RKH_STATE_CAST(&smPT_s0), 0, TRN_NOT_INTERNAL, 1, &evA,
2258 RKH_STATE_CAST(&smPT_s121));
2259
2260 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &evA);
2261 state = getHistory(&smPT_s1Hist);
2262 TEST_ASSERT_EQUAL_PTR(RKH_STATE_CAST(&smPT_s12), state);
2263
2264 p = unitrazer_getLastOut();
2265 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2266}
2267
2268void
2269test_pseudostateTrnToEmptyDeepHistoryWithoutDefaultTrn(void)
2270{
2271 UtrzProcessOut *p;
2272 int nExSt, nEnSt;
2273 RKH_EVT_T event;
2274
2275 nEnSt = 3;
2276 nExSt = 1;
2277 event = evC;
2278 expInitSm((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_waiting));
2279 sm_dch_expect(event.e, RKH_STATE_CAST(&smPT_s0));
2280 sm_trn_expect(RKH_STATE_CAST(&smPT_s0), RKH_STATE_CAST(&smPT_s12Hist));
2281 sm_tsState_expect(RKH_STATE_CAST(&smPT_s12Hist));
2282 sm_tsState_expect(RKH_STATE_CAST(&smPT_s12));
2283 sm_exstate_expect(RKH_STATE_CAST(&smPT_s0));
2284 sm_enstate_expect(RKH_STATE_CAST(&smPT_s1));
2285 sm_enstate_expect(RKH_STATE_CAST(&smPT_s12));
2286 sm_tsState_expect(RKH_STATE_CAST(&smPT_s121));
2287 sm_enstate_expect(RKH_STATE_CAST(&smPT_s121));
2288 sm_nenex_expect(nEnSt, nExSt);
2289 sm_state_expect(RKH_STATE_CAST(&smPT_s121));
2290 sm_evtProc_expect();
2291
2292 rkh_sm_init((RKH_SM_T *)smPseudoTest);
2293 setState((RKH_SMA_T *)smPseudoTest, RKH_STATE_CAST(&smPT_s0));
2294 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &event);
2295
2296 p = unitrazer_getLastOut();
2297 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2298}
2299
2300void
2301test_pseudostateTrnToLoadedDeepHistoryWithoutDefaultTrn(void)
2302{
2303 UtrzProcessOut *p;
2304
2305 stateList_create(targetStates, 2, &smPT_s12Hist, &smPT_s122);
2306 stateList_create(exitStates, 1, &smPT_s0);
2307 stateList_create(entryStates, 3, &smPT_s1, &smPT_s12, &smPT_s122);
2308 setProfile(smPseudoTest, RKH_STATE_CAST(&smPT_waiting),
2309 RKH_STATE_CAST(&smPT_s0),
2310 RKH_STATE_CAST(&smPT_s0), targetStates,
2311 entryStates, exitStates,
2312 RKH_STATE_CAST(&smPT_s122), 0, TRN_NOT_INTERNAL, 1, &evC,
2313 RKH_STATE_CAST(&smPT_s0));
2314
2315 setHistory(&smPT_s12Hist, RKH_STATE_CAST(&smPT_s122));
2316 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &evC);
2317
2318 p = unitrazer_getLastOut();
2319 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2320}
2321
2322void
2323test_pseudostateExitFromCompositeWithLoadedDeepHistory(void)
2324{
2325 UtrzProcessOut *p;
2326 const RKH_ST_T *state;
2327
2328 stateList_create(targetStates, 1, &smPT_s122);
2329 stateList_create(exitStates, 1, &smPT_s0);
2330 stateList_create(entryStates, 3, &smPT_s1, &smPT_s12, &smPT_s122);
2331 setProfile(smPseudoTest, RKH_STATE_CAST(&smPT_waiting),
2332 RKH_STATE_CAST(&smPT_s0),
2333 RKH_STATE_CAST(&smPT_s0), targetStates,
2334 entryStates, exitStates,
2335 RKH_STATE_CAST(&smPT_s122), 0, TRN_NOT_INTERNAL, 1, &evD,
2336 RKH_STATE_CAST(&smPT_s0));
2337
2338 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &evD);
2339 state = getHistory(&smPT_s12Hist);
2340 TEST_ASSERT_EQUAL_PTR(RKH_STATE_CAST(&smPT_s122), state);
2341
2342 p = unitrazer_getLastOut();
2343 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2344}
2345
2346void
2347test_pseudostateTrnToEmptyShallowHistoryWithDefaultTrn(void)
2348{
2349 UtrzProcessOut *p;
2350
2351 smPT_trueGuard_ExpectAndReturn(RKH_CAST(SmPseudoTest, smPseudoTest),
2352 &evE, RKH_TRUE);
2353 smPT_trS2History_Expect(RKH_CAST(SmPseudoTest, smPseudoTest), &evE);
2354
2355 stateList_create(targetStates, 2, &smPT_s2Hist, &smPT_s22);
2356 stateList_create(exitStates, 1, &smPT_s0);
2357 stateList_create(entryStates, 2, &smPT_s2, &smPT_s22);
2358 setProfile(smPseudoTest, RKH_STATE_CAST(&smPT_waiting),
2359 RKH_STATE_CAST(&smPT_s0),
2360 RKH_STATE_CAST(&smPT_s0), targetStates,
2361 entryStates, exitStates,
2362 RKH_STATE_CAST(&smPT_s22), 1, TRN_NOT_INTERNAL, 1, &evE,
2363 RKH_STATE_CAST(&smPT_s0));
2364
2365 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &evE);
2366
2367 p = unitrazer_getLastOut();
2368 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2369}
2370
2371void
2372test_pseudostateTrnToLoadedShallowHistoryWithDefaultTrn(void)
2373{
2374 UtrzProcessOut *p;
2375
2376 stateList_create(targetStates, 2, &smPT_s2Hist, &smPT_s21);
2377 stateList_create(exitStates, 1, &smPT_s0);
2378 stateList_create(entryStates, 2, &smPT_s2, &smPT_s21);
2379 setProfile(smPseudoTest, RKH_STATE_CAST(&smPT_waiting),
2380 RKH_STATE_CAST(&smPT_s0),
2381 RKH_STATE_CAST(&smPT_s0), targetStates,
2382 entryStates, exitStates,
2383 RKH_STATE_CAST(&smPT_s21), 0, TRN_NOT_INTERNAL, 1, &evE,
2384 RKH_STATE_CAST(&smPT_s0));
2385
2386 setHistory(&smPT_s2Hist, RKH_STATE_CAST(&smPT_s21));
2387 rkh_sm_dispatch((RKH_SM_T *)smPseudoTest, &evE);
2388
2389 p = unitrazer_getLastOut();
2390 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2391}
2392
2402void
2403test_InitPseudostateFirstStateAfterInit(void)
2404{
2405 UtrzProcessOut *p;
2406 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2407
2408 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2409 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2410 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0, NULL, NULL, NULL,
2411 &evCreation);
2412
2413 rkh_sm_init((RKH_SM_T *)me);
2414
2415 p = unitrazer_getLastOut();
2416 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2417}
2418
2419void
2420test_InitPseudostateTrnToEmptyShHistoryToSimpleState(void)
2421{
2422 UtrzProcessOut *p;
2423 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2424 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s1, (RKH_ST_T *)&smIPT_s1},
2425 {(RKH_ST_T *)&smIPT_s1Hist, NULL},
2426 {(RKH_ST_T *)&smIPT_s11, (RKH_ST_T *)&smIPT_s11},
2427 {NULL, NULL}};
2428
2429 stateList_create(exitStates, 1, &smIPT_s0);
2430
2431 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2432 smIPT_nS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2433 smIPT_xS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2434 smIPT_nS1_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2435 smIPT_tr1_Expect((SmInitialPseudoTest *)smInitialPseudoTest, &evA);
2436 smIPT_nS11_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2437
2438 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2439 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evA);
2440
2441 rkh_sm_init((RKH_SM_T *)me);
2442 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evA);
2443
2444 p = unitrazer_getLastOut();
2445 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2446}
2447
2448void
2449test_InitPseudostateTrnToLoadedShHistory(void)
2450{
2451 UtrzProcessOut *p;
2452 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2453 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s1, (RKH_ST_T *)&smIPT_s1},
2454 {(RKH_ST_T *)&smIPT_s1Hist, NULL },
2455 {(RKH_ST_T *)&smIPT_s12, (RKH_ST_T *)&smIPT_s12},
2456 {NULL, NULL }};
2457
2458 stateList_create(exitStates, 1, &smIPT_s0);
2459
2460 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2461 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2462 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2463 smIPT_nS1_Expect((SmInitialPseudoTest *)me);
2464 smIPT_nS12_Expect((SmInitialPseudoTest *)me);
2465
2466 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2467 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evA);
2468
2469 rkh_sm_init((RKH_SM_T *)me);
2470 setHistory(&smIPT_s1Hist, RKH_STATE_CAST(&smIPT_s12));
2471 rkh_sm_dispatch((RKH_SM_T *)me, &evA);
2472
2473 p = unitrazer_getLastOut();
2474 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2475}
2476
2477void
2478test_InitPseudostateTrnToEmptyShHistoryToCmpState(void)
2479{
2480 UtrzProcessOut *p;
2481 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2482 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s2, (RKH_ST_T *)&smIPT_s2},
2483 {(RKH_ST_T *)&smIPT_s2Hist, NULL},
2484 {(RKH_ST_T *)&smIPT_s21, (RKH_ST_T *)&smIPT_s21},
2485 {(RKH_ST_T *)&smIPT_s211, (RKH_ST_T *)&smIPT_s211 },
2486 {NULL, NULL}};
2487
2488 stateList_create(exitStates, 1, &smIPT_s0);
2489
2490 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2491 smIPT_nS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2492 smIPT_xS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2493 smIPT_nS2_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2494 smIPT_nS21_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2495 smIPT_nS211_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2496
2497 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2498 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evD);
2499
2500 rkh_sm_init((RKH_SM_T *)me);
2501 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evD);
2502
2503 p = unitrazer_getLastOut();
2504 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2505}
2506
2507void
2508test_InitPseudostateTrnToEmptyDeepHistoryToSimpleState(void)
2509{
2510 UtrzProcessOut *p;
2511 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2512 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s3, (RKH_ST_T *)&smIPT_s3},
2513 {(RKH_ST_T *)&smIPT_s3Hist, NULL},
2514 {(RKH_ST_T *)&smIPT_s31, (RKH_ST_T *)&smIPT_s31 },
2515 {NULL, NULL}};
2516
2517 stateList_create(exitStates, 1, &smIPT_s0);
2518
2519 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2520 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2521 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2522 smIPT_nS3_Expect((SmInitialPseudoTest *)me);
2523 smIPT_nS31_Expect((SmInitialPseudoTest *)me);
2524
2525 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2526 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evB);
2527
2528 rkh_sm_init((RKH_SM_T *)me);
2529 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evB);
2530
2531 p = unitrazer_getLastOut();
2532 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2533}
2534
2535void
2536test_InitPseudostateTrnToLoadedDeepHistory(void)
2537{
2538 UtrzProcessOut *p;
2539 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2540 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s3, (RKH_ST_T *)&smIPT_s3},
2541 {(RKH_ST_T *)&smIPT_s3Hist, NULL},
2542 {(RKH_ST_T *)&smIPT_s32, (RKH_ST_T *)&smIPT_s32},
2543 {NULL, NULL}};
2544
2545 stateList_create(exitStates, 1, &smIPT_s0);
2546
2547 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2548 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2549 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2550 smIPT_nS3_Expect((SmInitialPseudoTest *)me);
2551 smIPT_nS32_Expect((SmInitialPseudoTest *)me);
2552
2553 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2554 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evB);
2555
2556 rkh_sm_init((RKH_SM_T *)me);
2557 setHistory(&smIPT_s3Hist, RKH_STATE_CAST(&smIPT_s32));
2558 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evB);
2559
2560 p = unitrazer_getLastOut();
2561 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2562}
2563
2564void
2565test_InitPseudostateTrnToLoadedDeepHistoryToNestedState(void)
2566{
2567 UtrzProcessOut *p;
2568 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2569 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s3, (RKH_ST_T *)&smIPT_s3 },
2570 {(RKH_ST_T *)&smIPT_s3Hist, NULL},
2571 {(RKH_ST_T *)&smIPT_s331, (RKH_ST_T *)&smIPT_s33},
2572 {NULL, (RKH_ST_T *)&smIPT_s331},
2573 {NULL, NULL}};
2574
2575 stateList_create(exitStates, 1, &smIPT_s0);
2576
2577 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2578 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2579 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2580 smIPT_nS3_Expect((SmInitialPseudoTest *)me);
2581 smIPT_nS33_Expect((SmInitialPseudoTest *)me);
2582 smIPT_nS331_Expect((SmInitialPseudoTest *)me);
2583
2584 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2585 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evB);
2586
2587 rkh_sm_init((RKH_SM_T *)me);
2588 setHistory(&smIPT_s3Hist, RKH_STATE_CAST(&smIPT_s331));
2589 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evB);
2590
2591 p = unitrazer_getLastOut();
2592 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2593}
2594
2595void
2596test_InitPseudostateTrnToEmptyShHistoryToNestedSimpleState(void)
2597{
2598 UtrzProcessOut *p;
2599 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2600 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s4, (RKH_ST_T *)&smIPT_s4},
2601 {(RKH_ST_T *)&smIPT_s4Hist, NULL},
2602 {(RKH_ST_T *)&smIPT_s411, (RKH_ST_T *)&smIPT_s41},
2603 {NULL, (RKH_ST_T *)&smIPT_s411},
2604 {NULL, NULL}};
2605
2606 stateList_create(exitStates, 1, &smIPT_s0);
2607
2608 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2609 smIPT_nS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2610 smIPT_xS0_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2611 smIPT_nS4_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2612 smIPT_nS41_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2613 smIPT_nS411_Expect((SmInitialPseudoTest *)smInitialPseudoTest);
2614
2615 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2616 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evC);
2617
2618 rkh_sm_init((RKH_SM_T *)me);
2619 rkh_sm_dispatch((RKH_SM_T *)smInitialPseudoTest, &evC);
2620
2621 p = unitrazer_getLastOut();
2622 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2623}
2624
2625void
2626test_InitPseudostateTrnToBranchToSimpleState(void)
2627{
2628 UtrzProcessOut *p;
2629 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2630 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s5, (RKH_ST_T *)&smIPT_s5},
2631 {(RKH_ST_T *)&smIPT_choice1, NULL},
2632 {(RKH_ST_T *)&smIPT_s52, (RKH_ST_T *)&smIPT_s52},
2633 {NULL, NULL}};
2634
2635 //stateList_create(targetStates, 3, &smIPT_s5, &smIPT_choice1, &smIPT_s52);
2636 stateList_create(exitStates, 1, &smIPT_s0);
2637 //stateList_create(entryStates, 2, &smIPT_s5, &smIPT_s52);
2638
2639 /* Expect call actions */
2640 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2641 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2642 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2643 smIPT_nS5_Expect((SmInitialPseudoTest *)me);
2644 smIPT_tr2_Expect((SmInitialPseudoTest *)me, &evE);
2645 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_TRUE);
2646 smIPT_nS52_Expect((SmInitialPseudoTest *)me);
2647
2648 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2649 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evE);
2650
2651 rkh_sm_init((RKH_SM_T *)me);
2652 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2653
2654 p = unitrazer_getLastOut();
2655 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2656}
2657
2658void
2659test_InitPseudostateTrnToBranchToCmpState(void)
2660{
2661 UtrzProcessOut *p;
2662 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2663 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s5, (RKH_ST_T *)&smIPT_s5},
2664 {(RKH_ST_T *)&smIPT_choice1, NULL},
2665 {(RKH_ST_T *)&smIPT_s51, (RKH_ST_T *)&smIPT_s51},
2666 {(RKH_ST_T *)&smIPT_s511, (RKH_ST_T *)&smIPT_s511},
2667 {NULL, NULL}};
2668
2669 //stateList_create(targetStates, 4, &smIPT_s5, &smIPT_choice1, &smIPT_s51,
2670 // &smIPT_s511);
2671 stateList_create(exitStates, 1, &smIPT_s0);
2672 //stateList_create(entryStates, 3, &smIPT_s5, &smIPT_s51, &smIPT_s511);
2673
2674 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2675 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2676 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2677 smIPT_nS5_Expect((SmInitialPseudoTest *)me);
2678 smIPT_tr2_Expect((SmInitialPseudoTest *)me, &evE);
2679 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2680 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2681 smIPT_isC3_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2682 smIPT_isC4_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2683 smIPT_nS51_Expect((SmInitialPseudoTest *)me);
2684 smIPT_nS511_Expect((SmInitialPseudoTest *)me);
2685
2686 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2687 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evE);
2688
2689 rkh_sm_init((RKH_SM_T *)me);
2690 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2691
2692 p = unitrazer_getLastOut();
2693 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2694}
2695
2696void
2697test_InitPseudostateTrnToBranchToNestedSimpleState(void)
2698{
2699 UtrzProcessOut *p;
2700 SmInitialPseudoTest *me = RKH_CAST(SmInitialPseudoTest,
2701 smInitialPseudoTest);
2702 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s5, (RKH_ST_T *)&smIPT_s5},
2703 {(RKH_ST_T *)&smIPT_choice1, NULL},
2704 {(RKH_ST_T *)&smIPT_s511, (RKH_ST_T *)&smIPT_s51},
2705 {NULL, (RKH_ST_T *)&smIPT_s511},
2706 {NULL, NULL}};
2707
2708 stateList_create(exitStates, 1, &smIPT_s0);
2709
2710 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2711 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2712 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2713 smIPT_nS5_Expect((SmInitialPseudoTest *)me);
2714 smIPT_tr2_Expect((SmInitialPseudoTest *)me, &evE);
2715 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2716 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_TRUE);
2717 smIPT_nS51_Expect((SmInitialPseudoTest *)me);
2718 smIPT_nS511_Expect((SmInitialPseudoTest *)me);
2719
2720 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2721 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evE);
2722
2723 rkh_sm_init((RKH_SM_T *)me);
2724 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2725
2726 p = unitrazer_getLastOut();
2727 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2728}
2729
2730void
2731test_InitPseudostateTrnToBranchToNestedCmpState(void)
2732{
2733 UtrzProcessOut *p;
2734 SmInitialPseudoTest *me = RKH_CAST(SmInitialPseudoTest,
2735 smInitialPseudoTest);
2736 TargetEntrySt tgEnSt[6] = {{(RKH_ST_T *)&smIPT_s5, (RKH_ST_T *)&smIPT_s5},
2737 {(RKH_ST_T *)&smIPT_choice1, NULL},
2738 {(RKH_ST_T *)&smIPT_s512, (RKH_ST_T *)&smIPT_s51},
2739 {NULL, (RKH_ST_T *)&smIPT_s512},
2740 {(RKH_ST_T *)&smIPT_s5121, (RKH_ST_T *)&smIPT_s5121},
2741 {NULL, NULL}};
2742
2743 stateList_create(exitStates, 1, &smIPT_s0);
2744
2745 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2746 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2747 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2748 smIPT_nS5_Expect((SmInitialPseudoTest *)me);
2749 smIPT_tr2_Expect((SmInitialPseudoTest *)me, &evE);
2750 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2751 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2752 smIPT_isC3_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_TRUE);
2753 smIPT_nS51_Expect((SmInitialPseudoTest *)me);
2754 smIPT_nS512_Expect((SmInitialPseudoTest *)me);
2755 smIPT_nS5121_Expect((SmInitialPseudoTest *)me);
2756
2757 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2758 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evE);
2759
2760 rkh_sm_init((RKH_SM_T *)me);
2761 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2762
2763 p = unitrazer_getLastOut();
2764 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2765}
2766
2767void
2768test_InitPseudostateTrnToBranchToFinalState(void)
2769{
2770 UtrzProcessOut *p;
2771 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
2772 TargetEntrySt tgEnSt[4] =
2773 {{(RKH_ST_T *)&smIPT_s5, (RKH_ST_T *)&smIPT_s5},
2774 {(RKH_ST_T *)&smIPT_choice1, NULL},
2775 {(RKH_ST_T *)&smIPT_s5Final, (RKH_ST_T *)&smIPT_s5Final},
2776 {NULL, NULL}};
2777
2778 //stateList_create(targetStates, 3, &smIPT_s5, &smIPT_choice1, &smIPT_s52);
2779 stateList_create(exitStates, 1, &smIPT_s0);
2780 //stateList_create(entryStates, 2, &smIPT_s5, &smIPT_s52);
2781
2782 /* Expect call actions */
2783 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2784 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2785 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2786 smIPT_nS5_Expect((SmInitialPseudoTest *)me);
2787 smIPT_tr2_Expect((SmInitialPseudoTest *)me, &evE);
2788 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2789 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2790 smIPT_isC3_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_FALSE);
2791 smIPT_isC4_ExpectAndReturn((RKH_SM_T *)me, &evE, RKH_TRUE);
2792
2793 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2794 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evE);
2795
2796 /* Expectations for completion transition */
2797 stateList_create(targetStates, 1, &smIPT_s0);
2798 stateList_create(entryStates, 1, &smIPT_s0);
2799 stateList_create(exitStates, 2, &smIPT_s5Final, &smIPT_s5);
2800
2801 smIPT_xS5_Expect((SmInitialPseudoTest *)me);
2802 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2803
2804 setProfile(smInitialPseudoTest, RKH_STATE_CAST(&smIPT_s5),
2805 NULL, RKH_STATE_CAST(&smIPT_s5),
2806 targetStates, entryStates, exitStates,
2807 RKH_STATE_CAST(&smIPT_s0), 1, TRN_NOT_INTERNAL,
2808 NO_INIT_STATE_MACHINE, &evCompletion,
2809 RKH_STATE_CAST(&smIPT_s5Final));
2810
2811 rkh_sm_init((RKH_SM_T *)me);
2812 rkh_sm_dispatch((RKH_SM_T *)me, &evE);
2813
2814 p = unitrazer_getLastOut();
2815 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2816}
2817
2818void
2819test_InitPseudostateTrnToJunctionToSimpleState(void)
2820{
2821 UtrzProcessOut *p;
2822 SmInitialPseudoTest *me = RKH_CAST(SmInitialPseudoTest,
2823 smInitialPseudoTest);
2824 TargetEntrySt tgEnSt[4] = {{(RKH_ST_T *)&smIPT_s6, (RKH_ST_T *)&smIPT_s6},
2825 {(RKH_ST_T *)&smIPT_junction1, NULL},
2826 {(RKH_ST_T *)&smIPT_s62, (RKH_ST_T *)&smIPT_s62},
2827 {NULL, NULL}};
2828
2829 stateList_create(exitStates, 1, &smIPT_s0);
2830
2831 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2832 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2833 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2834 smIPT_nS6_Expect((SmInitialPseudoTest *)me);
2835 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evF, RKH_TRUE);
2836 smIPT_tr3_Expect((SmInitialPseudoTest *)me, &evF);
2837 smIPT_nS62_Expect((SmInitialPseudoTest *)me);
2838
2839 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2840 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evF);
2841
2842 rkh_sm_init((RKH_SM_T *)me);
2843 rkh_sm_dispatch((RKH_SM_T *)me, &evF);
2844
2845 p = unitrazer_getLastOut();
2846 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2847}
2848
2849void
2850test_InitPseudostateTrnToJunctionToCmpState(void)
2851{
2852 UtrzProcessOut *p;
2853 SmInitialPseudoTest *me = RKH_CAST(SmInitialPseudoTest,
2854 smInitialPseudoTest);
2855 TargetEntrySt tgEnSt[5] = {{(RKH_ST_T *)&smIPT_s6, (RKH_ST_T *)&smIPT_s6},
2856 {(RKH_ST_T *)&smIPT_junction1, NULL},
2857 {(RKH_ST_T *)&smIPT_s61, (RKH_ST_T *)&smIPT_s61},
2858 {(RKH_ST_T *)&smIPT_s611, (RKH_ST_T *)&smIPT_s611},
2859 {NULL, NULL}};
2860
2861 stateList_create(exitStates, 1, &smIPT_s0);
2862
2863 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2864 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
2865 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
2866 smIPT_nS6_Expect((SmInitialPseudoTest *)me);
2867 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, &evF, RKH_FALSE);
2868 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, &evF, RKH_FALSE);
2869 smIPT_isC3_ExpectAndReturn((RKH_SM_T *)me, &evF, RKH_FALSE);
2870 smIPT_tr3_Expect((SmInitialPseudoTest *)me, &evF);
2871 smIPT_nS61_Expect((SmInitialPseudoTest *)me);
2872 smIPT_nS611_Expect((SmInitialPseudoTest *)me);
2873
2874 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
2875 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evF);
2876
2877 rkh_sm_init((RKH_SM_T *)me);
2878 rkh_sm_dispatch((RKH_SM_T *)me, &evF);
2879
2880 p = unitrazer_getLastOut();
2881 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2882}
2883
2884void
2885test_InitPseudostateSMInitialToSimpleState(void)
2886{
2887 UtrzProcessOut *p;
2888 RKH_SM_T *me = smInitial0;
2889
2890 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2891 smI0_nS0_Expect((SmInitialPseudoTest *)me);
2892 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smI0_s0, NULL, NULL,
2893 NULL, &evCreation);
2894
2895 rkh_sm_init(me);
2896
2897 p = unitrazer_getLastOut();
2898 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2899}
2900
2901void
2902test_InitPseudostateSMInitialToCmpState(void)
2903{
2904 UtrzProcessOut *p;
2905 RKH_SM_T *me = smInitial1;
2906
2907 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2908 smI1_nS0_Expect((SmInitialPseudoTest *)me);
2909 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2910 smI1_nS01_Expect((SmInitialPseudoTest *)me);
2911 sm_init_expect(RKH_STATE_CAST(&smI1_s0));
2912 sm_trn_expect(RKH_STATE_CAST(&smI1_s0), RKH_STATE_CAST(&smI1_s0));
2913 sm_tsState_expect(RKH_STATE_CAST(&smI1_s0));
2914 sm_enstate_expect(RKH_STATE_CAST(&smI1_s0));
2915 sm_tsState_expect(RKH_STATE_CAST(&smI1_s01));
2916 sm_enstate_expect(RKH_STATE_CAST(&smI1_s01));
2917 sm_nenex_expect(2, 0);
2918 sm_state_expect(RKH_STATE_CAST(&smI1_s01));
2919 sm_evtProc_expect();
2920
2921 rkh_sm_init(me);
2922
2923 p = unitrazer_getLastOut();
2924 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2925}
2926
2927void
2928test_InitPseudostateSMInitialToNestedSimpleState(void)
2929{
2930 UtrzProcessOut *p;
2931 RKH_SM_T *me = smInitial2;
2932
2933 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2934 smI2_nS0_Expect((SmInitialPseudoTest *)me);
2935 smI2_nS01_Expect((SmInitialPseudoTest *)me);
2936 sm_init_expect(RKH_STATE_CAST(&smI2_s01));
2937 sm_trn_expect(RKH_STATE_CAST(&smI2_s01), RKH_STATE_CAST(&smI2_s01));
2938 sm_tsState_expect(RKH_STATE_CAST(&smI2_s01));
2939 sm_enstate_expect(RKH_STATE_CAST(&smI2_s0));
2940 sm_enstate_expect(RKH_STATE_CAST(&smI2_s01));
2941 sm_nenex_expect(2, 0);
2942 sm_state_expect(RKH_STATE_CAST(&smI2_s01));
2943 sm_evtProc_expect();
2944
2945 rkh_sm_init(me);
2946
2947 p = unitrazer_getLastOut();
2948 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2949}
2950
2951void
2952test_InitPseudostateSMInitialToNestedCmpState(void)
2953{
2954 UtrzProcessOut *p;
2955 RKH_SM_T *me = smInitial3;
2956
2957 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2958 smI3_nS0_Expect((SmInitialPseudoTest *)me);
2959 smI3_nS01_Expect((SmInitialPseudoTest *)me);
2960 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2961 smI3_nS011_Expect((SmInitialPseudoTest *)me);
2962 sm_init_expect(RKH_STATE_CAST(&smI3_s01));
2963 sm_trn_expect(RKH_STATE_CAST(&smI3_s01), RKH_STATE_CAST(&smI3_s01));
2964 sm_tsState_expect(RKH_STATE_CAST(&smI3_s01));
2965 sm_enstate_expect(RKH_STATE_CAST(&smI3_s0));
2966 sm_enstate_expect(RKH_STATE_CAST(&smI3_s01));
2967 sm_tsState_expect(RKH_STATE_CAST(&smI3_s011));
2968 sm_enstate_expect(RKH_STATE_CAST(&smI3_s011));
2969 sm_nenex_expect(3, 0);
2970 sm_state_expect(RKH_STATE_CAST(&smI3_s011));
2971 sm_evtProc_expect();
2972
2973 rkh_sm_init(me);
2974
2975 p = unitrazer_getLastOut();
2976 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
2977}
2978
2979void
2980test_InitPseudostateSMInitialToJunctionToSimpleState(void)
2981{
2982 UtrzProcessOut *p;
2983 RKH_SM_T *me = smInitial4;
2984
2985 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
2986 RKH_TRUE);
2987 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2988 smIPT_tr1_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
2989 smI4_nS0_Expect((SmInitialPseudoTest *)me);
2990 sm_init_expect(RKH_STATE_CAST(&smI4_junction1));
2991 sm_trn_expect(RKH_STATE_CAST(&smI4_junction1),
2992 RKH_STATE_CAST(&smI4_junction1));
2993 sm_tsState_expect(RKH_STATE_CAST(&smI4_junction1));
2994 sm_tsState_expect(RKH_STATE_CAST(&smI4_s0));
2995 sm_enstate_expect(RKH_STATE_CAST(&smI4_s0));
2996 sm_nenex_expect(1, 0);
2997 sm_state_expect(RKH_STATE_CAST(&smI4_s0));
2998 sm_evtProc_expect();
2999
3000 rkh_sm_init(me);
3001
3002 p = unitrazer_getLastOut();
3003 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3004}
3005
3006void
3007test_InitPseudostateSMInitialToJunctionToCmpState(void)
3008{
3009 UtrzProcessOut *p;
3010 RKH_SM_T *me = smInitial4;
3011
3012 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
3013 RKH_FALSE);
3014 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
3015 RKH_TRUE);
3016 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3017 smIPT_tr2_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3018 smI4_nS1_Expect((SmInitialPseudoTest *)me);
3019 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3020 smI4_nS11_Expect((SmInitialPseudoTest *)me);
3021 sm_init_expect(RKH_STATE_CAST(&smI4_junction1));
3022 sm_trn_expect(RKH_STATE_CAST(&smI4_junction1),
3023 RKH_STATE_CAST(&smI4_junction1));
3024 sm_tsState_expect(RKH_STATE_CAST(&smI4_junction1));
3025 sm_tsState_expect(RKH_STATE_CAST(&smI4_s1));
3026 sm_enstate_expect(RKH_STATE_CAST(&smI4_s1));
3027 sm_tsState_expect(RKH_STATE_CAST(&smI4_s11));
3028 sm_enstate_expect(RKH_STATE_CAST(&smI4_s11));
3029 sm_nenex_expect(2, 0);
3030 sm_state_expect(RKH_STATE_CAST(&smI4_s11));
3031 sm_evtProc_expect();
3032
3033 rkh_sm_init(me);
3034
3035 p = unitrazer_getLastOut();
3036 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3037}
3038
3039void
3040test_InitPseudostateSMInitialToBranchToSimpleState(void)
3041{
3042 UtrzProcessOut *p;
3043 RKH_SM_T *me = smInitial5;
3044
3045 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3046 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
3047 RKH_TRUE);
3048 smIPT_tr1_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3049 smI5_nS0_Expect((SmInitialPseudoTest *)me);
3050 sm_init_expect(RKH_STATE_CAST(&smI5_branch1));
3051 sm_trn_expect(RKH_STATE_CAST(&smI5_branch1),
3052 RKH_STATE_CAST(&smI5_branch1));
3053 sm_tsState_expect(RKH_STATE_CAST(&smI5_branch1));
3054 sm_tsState_expect(RKH_STATE_CAST(&smI5_s0));
3055 sm_enstate_expect(RKH_STATE_CAST(&smI5_s0));
3056 sm_nenex_expect(1, 0);
3057 sm_state_expect(RKH_STATE_CAST(&smI5_s0));
3058 sm_evtProc_expect();
3059
3060 rkh_sm_init(me);
3061
3062 p = unitrazer_getLastOut();
3063 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3064}
3065
3066void
3067test_InitPseudostateSMInitialToBranchToCmpState(void)
3068{
3069 UtrzProcessOut *p;
3070 RKH_SM_T *me = smInitial5;
3071
3072 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3073 smIPT_isC1_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
3074 RKH_FALSE);
3075 smIPT_isC2_ExpectAndReturn((RKH_SM_T *)me, (RKH_EVT_T *)&evCreation,
3076 RKH_TRUE);
3077 smIPT_tr2_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3078 smI5_nS1_Expect((SmInitialPseudoTest *)me);
3079 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3080 smI5_nS11_Expect((SmInitialPseudoTest *)me);
3081 sm_init_expect(RKH_STATE_CAST(&smI5_branch1));
3082 sm_trn_expect(RKH_STATE_CAST(&smI5_branch1),
3083 RKH_STATE_CAST(&smI5_branch1));
3084 sm_tsState_expect(RKH_STATE_CAST(&smI5_branch1));
3085 sm_tsState_expect(RKH_STATE_CAST(&smI5_s1));
3086 sm_enstate_expect(RKH_STATE_CAST(&smI5_s1));
3087 sm_tsState_expect(RKH_STATE_CAST(&smI5_s11));
3088 sm_enstate_expect(RKH_STATE_CAST(&smI5_s11));
3089 sm_nenex_expect(2, 0);
3090 sm_state_expect(RKH_STATE_CAST(&smI5_s11));
3091 sm_evtProc_expect();
3092
3093 rkh_sm_init(me);
3094
3095 p = unitrazer_getLastOut();
3096 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3097}
3098
3099void
3100test_InitPseudostateTrnToInitialToSimpleStateWithNullTrn(void)
3101{
3102 UtrzProcessOut *p;
3103 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitialPseudoTest;
3104 TargetEntrySt tgEnSt[3] = {{(RKH_ST_T *)&smIPT_s7, (RKH_ST_T *)&smIPT_s7},
3105 {(RKH_ST_T *)&smIPT_s71, (RKH_ST_T *)&smIPT_s71},
3106 {NULL, NULL}};
3107
3108 stateList_create(exitStates, 1, &smIPT_s0);
3109
3110 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3111 smIPT_nS0_Expect((SmInitialPseudoTest *)me);
3112 smIPT_xS0_Expect((SmInitialPseudoTest *)me);
3113 smIPT_nS7_Expect((SmInitialPseudoTest *)me);
3114 smIPT_nS71_Expect((SmInitialPseudoTest *)me);
3115 smIPT_xS71_Expect((SmInitialPseudoTest *)me);
3116 smIPT_tr4_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCompletion);
3117 smIPT_nS72_Expect((SmInitialPseudoTest *)me);
3118
3119 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smIPT_s0,
3120 (RKH_ST_T *)&smIPT_s0, tgEnSt, exitStates, &evG);
3121
3122 /* Transition (null or completion) from s71 to s72 */
3123 sm_dch_expect(evCompletion.e, RKH_STATE_CAST(&smIPT_s71));
3124 sm_trn_expect(RKH_STATE_CAST(&smIPT_s71), RKH_STATE_CAST(&smIPT_s72));
3125 sm_tsState_expect(RKH_STATE_CAST(&smIPT_s72));
3126 sm_exstate_expect(RKH_STATE_CAST(&smIPT_s71));
3127 sm_enstate_expect(RKH_STATE_CAST(&smIPT_s72));
3128 sm_nenex_expect(1, 1);
3129 sm_state_expect(RKH_STATE_CAST(&smIPT_s72));
3130 sm_evtProc_expect();
3131
3132 rkh_sm_init((RKH_SM_T *)me);
3133 rkh_sm_dispatch((RKH_SM_T *)me, &evG);
3134
3135 p = unitrazer_getLastOut();
3136 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3137}
3138
3139void
3140test_InitPseudostateSMInitialToSimpleStateWithNullTrn(void)
3141{
3142 UtrzProcessOut *p;
3143 SmInitialPseudoTest *me = (SmInitialPseudoTest *)smInitial6;
3144
3145 smIPT_init_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCreation);
3146 smIPT_tr4_Expect((SmInitialPseudoTest *)me, (RKH_EVT_T *)&evCompletion);
3147 trnStepExpect((RKH_SM_T *)me, (RKH_ST_T *)&smI6_s0, NULL, NULL,
3148 NULL, &evCreation);
3149
3150 /* Transition (null or completion) from s0 to s1 */
3151 sm_dch_expect(evCompletion.e, RKH_STATE_CAST(&smI6_s0));
3152 sm_trn_expect(RKH_STATE_CAST(&smI6_s0), RKH_STATE_CAST(&smI6_s1));
3153 sm_tsState_expect(RKH_STATE_CAST(&smI6_s1));
3154 sm_exstate_expect(RKH_STATE_CAST(&smI6_s0));
3155 sm_enstate_expect(RKH_STATE_CAST(&smI6_s1));
3156 sm_nenex_expect(1, 1);
3157 sm_state_expect(RKH_STATE_CAST(&smI6_s1));
3158 sm_evtProc_expect();
3159
3160 rkh_sm_init((RKH_SM_T *)me);
3161
3162 p = unitrazer_getLastOut();
3163 TEST_ASSERT_EQUAL(UT_PROC_SUCCESS, p->status);
3164}
3165
3171/* ------------------------------ End of file ------------------------------ */
RKH_UPCAST
#define RKH_UPCAST(BaseType_, me_)
Convert a pointer to a base-class.
Definition rkhfwk_cast.h:74
RKH_FALSE
#define RKH_FALSE
Standard define.
Definition rkhdef.h:256
RKH_TRUE
#define RKH_TRUE
Standard define.
Definition rkhdef.h:257
RKH_STATIC_EVENT
#define RKH_STATIC_EVENT(ev_obj, ev_sig)
This macro declares and initializes the event structure ev_ob with ev_sig signal number and establish...
Definition rkhfwk_dynevt.h:243
rkh_sm_dispatch
ruint rkh_sm_dispatch(RKH_SM_T *me, RKH_EVT_T *e)
Executes a state machine in a run-to-completation (RTC) model.
rkh_sm_propagate
void rkh_sm_propagate(RKH_SM_T *me, RKH_EVT_T *e)
Propagate an event to self. This event will be processed subsequently, without exiting from the curre...
RKH_RCODE_T
RKH_RCODE_T
Return codes from rkh_sm_dispatch() function.
Definition rkhsm.h:1559
rkh_sm_init
void rkh_sm_init(RKH_SM_T *me)
Inits a previously created state machine calling its initializing action.
rkh_sm_clear_history
void rkh_sm_clear_history(RKHROM RKH_SHIST_T *h)
Erase the history of a state. It can be a shallow or deep history.
RKH_EVT_NFOUND
@ RKH_EVT_NFOUND
Definition rkhsm.h:1569
RKH_EX_HLEVEL
@ RKH_EX_HLEVEL
Definition rkhsm.h:1590
RKH_EVT_PROC
@ RKH_EVT_PROC
Definition rkhsm.h:1564
rkhfwk_bittbl.h
Specifies the interface of the mapping table manager to deal with native priority algorithm.
RKH_CAST
#define RKH_CAST(_type, _obj)
Perform downcast of a reference of a base class to one of its derived classes.
Definition rkhfwk_cast.h:107
rkhsm.h
Specifies the interface of the state-machine manager.
rkhtrc.h
Specifies the interface of trace facility.
RKH_TG_SM
#define RKH_TG_SM
State Machine group (SM)
Definition rkhtrc_define.h:324
RKH_TE_FWK_ASSERT
#define RKH_TE_FWK_ASSERT
Definition rkhtrc_define.h:468
rkhtrc_filter.h
Specifies the runtime filter operations for the trace facility.
rkhtrc_record.h
Defines the trace records.
rkhtrc_stream.h
Specifies the trace stream manager (circular buffer).
RKH_EVT_T
Represents events without parameters.
Definition rkhevt.h:170
RKH_EVT_T::e
RKH_SIG_T e
Signal of the event instance.
Definition rkhevt.h:175
RKH_SM_T
Describes the state machine.
Definition rkhsm.h:1927
RKH_SMA_T
Describes the SMA (active object in UML).
Definition rkhsma.h:772
RKH_ST_T
Describes the common properties of regular states (basic, composite, and submachine).
Definition rkhsm.h:2078
unitrazer.h
Interface of unit test with Trazer application.
sm_cleanup
#define sm_cleanup()
Return the system under test to its initial state after the test.
Definition unitrazer.h:85
sm_init
#define sm_init()
Establish the preconditions to the tests.
Definition unitrazer.h:79
sm_verify
#define sm_verify()
Makes sure there are no unused expectations, if there are, this function causes the test to fail.
Definition unitrazer.h:92