| ////////////////////////////////////////////////////////////////////////////// |
| // Copyright 2004-2006 Andreas Huber Doenni |
| // Distributed under the Boost Software License, Version 1.0. (See accompany- |
| // ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) |
| ////////////////////////////////////////////////////////////////////////////// |
| |
| |
| |
| #include <boost/statechart/state_machine.hpp> |
| #include <boost/statechart/event.hpp> |
| #include <boost/statechart/simple_state.hpp> |
| #include <boost/statechart/transition.hpp> |
| #include <boost/statechart/deferral.hpp> |
| #include <boost/statechart/custom_reaction.hpp> |
| |
| #include <boost/mpl/list.hpp> |
| #include <boost/intrusive_ptr.hpp> |
| |
| #include <boost/test/test_tools.hpp> |
| |
| |
| |
| namespace sc = boost::statechart; |
| namespace mpl = boost::mpl; |
| |
| |
| |
| template< class T > |
| boost::intrusive_ptr< T > MakeIntrusive( T * pT ) |
| { |
| return boost::intrusive_ptr< T >( pT ); |
| } |
| |
| struct EvLeafDeferred : sc::event< EvLeafDeferred > {}; |
| struct EvNodeDeferred : sc::event< EvNodeDeferred > {}; |
| struct EvSwitch : sc::event< EvSwitch > {}; |
| struct EvDestroy : sc::event< EvDestroy > {}; |
| |
| struct Active; |
| struct DeferralTest : sc::state_machine< DeferralTest, Active > |
| { |
| ////////////////////////////////////////////////////////////////////////// |
| DeferralTest() : processedCount_( 0 ) {} |
| |
| void IncrementProcessedCount() |
| { |
| ++processedCount_; |
| } |
| |
| unsigned int ProcessedCount() const |
| { |
| return processedCount_; |
| } |
| |
| private: |
| ////////////////////////////////////////////////////////////////////////// |
| unsigned int processedCount_; |
| }; |
| |
| struct Dead : sc::simple_state< Dead, DeferralTest > |
| { |
| typedef sc::custom_reaction< EvNodeDeferred > reactions; |
| |
| sc::result react( const EvNodeDeferred & ) |
| { |
| outermost_context().IncrementProcessedCount(); |
| return discard_event(); |
| } |
| }; |
| |
| struct Idle; |
| struct Active : sc::simple_state< Active, DeferralTest, Idle > |
| { |
| typedef mpl::list< |
| sc::custom_reaction< EvLeafDeferred >, |
| sc::deferral< EvNodeDeferred >, |
| sc::transition< EvDestroy, Dead > |
| > reactions; |
| |
| sc::result react( const EvLeafDeferred & ) |
| { |
| outermost_context().IncrementProcessedCount(); |
| return discard_event(); |
| } |
| }; |
| |
| struct Running : sc::simple_state< Running, Active > |
| { |
| typedef sc::transition< EvSwitch, Idle > reactions; |
| }; |
| |
| struct Idle : sc::simple_state< Idle, Active > |
| { |
| typedef mpl::list< |
| sc::transition< EvSwitch, Running >, |
| sc::deferral< EvLeafDeferred > |
| > reactions; |
| }; |
| |
| |
| struct EvToX2 : sc::event< EvToX2 > {}; |
| struct EvToX3 : sc::event< EvToX3 > {}; |
| |
| struct X1; |
| struct DeferralEventBaseTest : sc::state_machine< DeferralEventBaseTest, X1 > |
| { |
| }; |
| |
| struct X3 : sc::simple_state< X3, DeferralEventBaseTest > {}; |
| |
| struct X2 : sc::simple_state< X2, DeferralEventBaseTest > |
| { |
| typedef sc::transition< EvToX3, X3 > reactions; |
| }; |
| |
| struct X1 : sc::simple_state< X1, DeferralEventBaseTest > |
| { |
| typedef mpl::list< |
| sc::transition< EvToX2, X2 >, |
| sc::deferral< sc::event_base > |
| > reactions; |
| }; |
| |
| |
| int test_main( int, char* [] ) |
| { |
| DeferralTest machine; |
| machine.initiate(); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 0 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 0 ); |
| machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 0 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 1 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 1 ); |
| machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) ); |
| machine.process_event( *MakeIntrusive( new EvLeafDeferred() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 1 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 3 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 3 ); |
| machine.process_event( *MakeIntrusive( new EvNodeDeferred() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 3 ); |
| machine.process_event( *MakeIntrusive( new EvSwitch() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 3 ); |
| machine.process_event( EvNodeDeferred() ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 3 ); |
| machine.process_event( *MakeIntrusive( new EvDestroy() ) ); |
| BOOST_REQUIRE( machine.ProcessedCount() == 5 ); |
| |
| |
| DeferralEventBaseTest eventBaseMachine; |
| // state_cast sanity check |
| BOOST_REQUIRE_THROW( eventBaseMachine.state_cast< const X1 & >(), std::bad_cast ); |
| eventBaseMachine.initiate(); |
| BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() ); |
| // Deferral must work with heap-allocated and stack-allocated events |
| eventBaseMachine.process_event( EvToX3() ); |
| BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() ); |
| eventBaseMachine.process_event( EvToX2() ); |
| BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X3 & >() ); |
| eventBaseMachine.initiate(); |
| BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X1 & >() ); |
| eventBaseMachine.process_event( EvToX2() ); |
| BOOST_REQUIRE_NO_THROW( eventBaseMachine.state_cast< const X2 & >() ); |
| |
| return 0; |
| } |