GEP_UNITTEST_TEST(StateMachine, INSERT_TEST_NAME_HERE) { GEP_UNITTEST_SETUP_EVENT_GLOBALS; auto& logging = TestLogging::instance(); //DummyLogging::instance(); // set up update framework _updateFramework.setElapsedTime(10.0f); // Add at least one callback so we know that we are still updating size_t frameCount = 0; _updateFramework.registerUpdateCallback([&](float){ logging.logWarning("frame %u:", frameCount); }); StateMachineFactory factory(&g_stdAllocator); StateMachine* pMainFsm = nullptr; // Test data. /// TODO Insert test data here /////////////////////////////////////////// // Actual tests. Don't put test data in here that has to be referenced // by the state machines, as they will get out of scope when pMainFsm // is actually run. { pMainFsm = factory.create("fsm"); /// TODO Insert test code here /////////////////////////////////////////// } pMainFsm->setLogging(&logging); // Run the machine pMainFsm->run(_updateFramework); for(frameCount = 0; frameCount < 20; ++frameCount) { _updateFramework.run(); } }
GEP_UNITTEST_TEST(StateMachine, UpdateStepBehavior) { GEP_UNITTEST_SETUP_EVENT_GLOBALS; auto& logging = TestLogging::instance(); //DummyLogging::instance(); // set up update framework _updateFramework.setElapsedTime(10.0f); // Add at least one callback so we know that we are still updating size_t frameCount = 0; _updateFramework.registerUpdateCallback([&](float){ logging.logWarning("frame %u:", frameCount); }); StateMachineFactory factory(&g_stdAllocator); StateMachine* pMainFsm = nullptr; // Test data. size_t conditionCheckCount = 0; size_t updateCount = 0; // Actual tests. Don't put test data in here that has to be referenced // by the state machines, as they will get out of scope when pMainFsm // is actually run. { pMainFsm = factory.create("fsm"); pMainFsm->setLogging(&logging); auto pState_A = pMainFsm->create<State>("A"); auto pState_B = pMainFsm->create<State>("B"); auto pState_C = pMainFsm->create<State>("C"); pState_C->setLeaveCondition([](){ return true; }); // Adding state transitions pMainFsm->addTransition("__enter", "A"); pMainFsm->addTransition("A", "B", [&](){ // This should be hit conditionCheckCount++; return true; }); pMainFsm->addTransition("B", "C", [&](){ // This should not be hit conditionCheckCount++; return true; }); pMainFsm->addTransition("C", "__leave"); pState_B->getLeaveEvent()->registerListener([&](State::LeaveEventData* pData){ GEP_ASSERT(conditionCheckCount == 1, "Condition check 'A->B' not performed!"); conditionCheckCount = 0; pData->setNextState(pState_C); return gep::EventResult::Handled; }); pState_C->getLeaveEvent()->registerListener([&](State::LeaveEventData*){ GEP_ASSERT(conditionCheckCount == 0, "Condition check 'B->C' should not have been performed!"); conditionCheckCount = 0; return gep::EventResult::Handled; }); // Set update event listeners. They should use the UpdateStepBehavior options. ////////////////////////////////////////////////////////////////////////// pState_A->getUpdateEvent()->registerListener([&](State::UpdateEventData* pData){ pData->setUpdateStepBehavior(State::UpdateStepBehavior::Leave); updateCount++; return gep::EventResult::Handled; }); pState_B->getUpdateEvent()->registerListener([&](State::UpdateEventData* pData){ pData->setUpdateStepBehavior(State::UpdateStepBehavior::LeaveWithNoConditionChecks); return gep::EventResult::Handled; }); } pMainFsm->setLogging(&logging); // Run the machine pMainFsm->run(_updateFramework); for(frameCount = 0; frameCount < 5; ++frameCount) { _updateFramework.run(); } GEP_ASSERT(updateCount > 0, "State A should have at least be updated once!"); }
GEP_UNITTEST_TEST(StateMachine, Basics) { GEP_UNITTEST_SETUP_EVENT_GLOBALS; auto& logging = TestLogging::instance(); //DummyLogging::instance(); // set up update framework _updateFramework.setElapsedTime(10.0f); // Add at least one callback so we know that we are still updating size_t frameCount = 0; _updateFramework.registerUpdateCallback([&](float){ logging.logWarning("frame %u:", frameCount); }); StateMachineFactory factory(&g_stdAllocator); StateMachine* pMainFsm = nullptr; // test data size_t testData_A = 0; size_t testData_B = 0; const size_t numTestStages = 9; size_t testStages[numTestStages] = { 0 }; // actual test { auto pFsm = pMainFsm = factory.create("fsm"); pFsm->setLogging(&logging); // Adding states auto pState_A = pFsm->create<State>("A"); auto state_B = pFsm->create<State>("B"); // Adding state transitions pFsm->addTransition("__enter", "A"); pFsm->addTransition("A", "B"); pFsm->addTransition("B", "__leave"); // Set state leave conditions pState_A->setLeaveCondition([&](){ return frameCount == 3; }); state_B->setLeaveCondition([&](){ return frameCount == 6; }); // Set some listeners pFsm->getEnterEvent()->registerListener([&](State::EnterEventData*){ testStages[0]++; return gep::EventResult::Handled; }); pFsm->getLeaveEvent()->registerListener([&](State::LeaveEventData*){ testStages[1]++; return gep::EventResult::Handled; }); pFsm->getUpdateEvent()->registerListener([&](State::UpdateEventData*){ testStages[2]++; return gep::EventResult::Handled; }); pState_A->getEnterEvent()->registerListener([&](State::EnterEventData*){ testStages[3]++; return gep::EventResult::Handled; }); pState_A->getLeaveEvent()->registerListener([&](State::LeaveEventData*){ testStages[4]++; return gep::EventResult::Handled; }); pState_A->getUpdateEvent()->registerListener([&](State::UpdateEventData*){ testStages[5]++; testData_A++; return gep::EventResult::Handled; }); state_B->getEnterEvent()->registerListener([&](State::EnterEventData*){ testStages[6]++; return gep::EventResult::Handled; }); state_B->getLeaveEvent()->registerListener([&](State::LeaveEventData*){ testStages[7]++; return gep::EventResult::Handled; }); state_B->getUpdateEvent()->registerListener([&](State::UpdateEventData*){ testStages[8]++; testData_B++; return gep::EventResult::Handled; }); } pMainFsm->setLogging(&logging); // Run the machine pMainFsm->run(_updateFramework); for(frameCount = 0; frameCount < 10; ++frameCount) { _updateFramework.run(); } }