1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
|
// Copyright 2025 Christian Granzin
// Copyright 2010 Christophe Henry
// henry UNDERSCORE christophe AT hotmail DOT com
// This is an extended version of the state machine available in the boost::mpl library
// Distributed under the same license as the original.
// Copyright for the original version:
// Copyright 2005 David Abrahams and Aleksey Gurtovoy. Distributed
// under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
// back-end
#include <boost/msm/backmp11/state_machine.hpp>
//front-end
#include <boost/msm/front/state_machine_def.hpp>
#include <boost/msm/front/functor_row.hpp>
#include <boost/msm/back/queue_container_circular.hpp>
#include <boost/msm/back/history_policies.hpp>
#ifndef BOOST_MSM_NONSTANDALONE_TEST
#define BOOST_TEST_MODULE backmp11_members_test
#endif
#include <boost/test/unit_test.hpp>
namespace msm = boost::msm;
namespace mp11 = boost::mp11;
using namespace msm::front;
using namespace msm::backmp11;
namespace
{
// Events.
struct MyEvent{};
// Actions
struct MyAction
{
template<typename Event, typename Fsm, typename Source, typename Target>
void operator()(const Event&, Fsm& fsm, Source&, Target&)
{
fsm.action_calls++;
}
};
struct MyGuard
{
template<typename Event, typename Fsm, typename Source, typename Target>
bool operator()(const Event&, Fsm& fsm, Source&, Target&) const
{
fsm.guard_calls++;
return true;
}
};
// States.
struct Default : public state<>{};
class StateMachine;
struct SmConfig : state_machine_config
{
using root_sm = StateMachine;
};
struct StateMachine_ : public state_machine_def<StateMachine_>
{
using activate_deferred_events = int;
template <typename Event, typename Fsm>
void on_entry(const Event& /*event*/, Fsm& fsm)
{
fsm.entry_calls++;
};
template <typename Event, typename Fsm>
void on_exit(const Event& /*event*/, Fsm& fsm)
{
fsm.machine_exits++;
};
using initial_state = Default;
using transition_table = mp11::mp_list<
Row<Default, MyEvent, none, MyAction, MyGuard>
>;
};
// Leave this class without inheriting constructors to check
// that this only needs to be done in case we use a context
// (for convenience).
class StateMachine : public state_machine<StateMachine_, SmConfig, StateMachine>
{
public:
size_t entry_calls{};
size_t machine_exits{};
size_t action_calls{};
size_t guard_calls{};
};
BOOST_AUTO_TEST_CASE( backmp11_members_test )
{
StateMachine test_machine;
[[maybe_unused]] auto& events_queue = test_machine.get_events_queue();
[[maybe_unused]] const auto& const_events_queue = static_cast<const StateMachine*>(&test_machine)->get_events_queue();
[[maybe_unused]] auto& deferred_events_queue = test_machine.get_deferred_events_queue();
[[maybe_unused]] const auto& const_deferred_events_queue = static_cast<const StateMachine*>(&test_machine)->get_deferred_events_queue();
test_machine.start();
BOOST_CHECK_MESSAGE(test_machine.entry_calls == 1, "SM on_entry not called correctly");
test_machine.process_event(MyEvent{});
BOOST_CHECK_MESSAGE(test_machine.action_calls == 1, "SM action not called correctly");
BOOST_CHECK_MESSAGE(test_machine.guard_calls == 1, "SM guard not called correctly");
test_machine.stop();
BOOST_CHECK_MESSAGE(test_machine.machine_exits == 1, "SM on_exit not called correctly");
}
} // namespace
|
