folly/futures/test/FSM.cpp

   1 /*
   2  * Copyright 2014 Facebook, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *   http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <gtest/gtest.h>
  18 #include <folly/futures/detail/FSM.h>
  19
  20 using namespace folly::wangle::detail;
  21
  22 enum class State { A, B };
  23
  24 TEST(FSM, example) {
  25   FSM<State> fsm(State::A);
  26   int count = 0;
  27   int unprotectedCount = 0;
  28
  29   // somebody set up us the switch
  30   auto tryTransition = [&]{
  31     switch (fsm.getState()) {
  32     case State::A:
  33       return fsm.updateState(State::A, State::B, [&]{ count++; });
  34     case State::B:
  35       return fsm.updateState(State::B, State::A,
  36                              [&]{ count--; }, [&]{ unprotectedCount--; });
  37     }
  38     return false; // unreachable
  39   };
  40
  41   // keep retrying until success (like a cas)
  42   while (!tryTransition()) ;
  43   EXPECT_EQ(State::B, fsm.getState());
  44   EXPECT_EQ(1, count);
  45   EXPECT_EQ(0, unprotectedCount);
  46
  47   while (!tryTransition()) ;
  48   EXPECT_EQ(State::A, fsm.getState());
  49   EXPECT_EQ(0, count);
  50   EXPECT_EQ(-1, unprotectedCount);
  51 }
  52
  53 TEST(FSM, magicMacrosExample) {
  54   struct MyFSM : public FSM<State> {
  55     int count = 0;
  56     int unprotectedCount = 0;
  57     MyFSM() : FSM<State>(State::A) {}
  58     void twiddle() {
  59       FSM_START
  60         FSM_CASE(State::A, State::B, [&]{ count++; });
  61         FSM_CASE2(State::B, State::A,
  62                   [&]{ count--; }, [&]{ unprotectedCount--; });
  63       FSM_END
  64     }
  65   };
  66
  67   MyFSM fsm;
  68
  69   fsm.twiddle();
  70   EXPECT_EQ(State::B, fsm.getState());
  71   EXPECT_EQ(1, fsm.count);
  72   EXPECT_EQ(0, fsm.unprotectedCount);
  73
  74   fsm.twiddle();
  75   EXPECT_EQ(State::A, fsm.getState());
  76   EXPECT_EQ(0, fsm.count);
  77   EXPECT_EQ(-1, fsm.unprotectedCount);
  78 }
  79
  80
  81 TEST(FSM, ctor) {
  82   FSM<State> fsm(State::A);
  83   EXPECT_EQ(State::A, fsm.getState());
  84 }
  85
  86 TEST(FSM, update) {
  87   FSM<State> fsm(State::A);
  88   EXPECT_TRUE(fsm.updateState(State::A, State::B, []{}));
  89   EXPECT_EQ(State::B, fsm.getState());
  90 }
  91
  92 TEST(FSM, badUpdate) {
  93   FSM<State> fsm(State::A);
  94   EXPECT_FALSE(fsm.updateState(State::B, State::A, []{}));
  95 }
  96
  97 TEST(FSM, actionOnUpdate) {
  98   FSM<State> fsm(State::A);
  99   int count = 0;
 100   fsm.updateState(State::A, State::B, [&]{ count++; });
 101   EXPECT_EQ(1, count);
 102 }
 103
 104 TEST(FSM, noActionOnBadUpdate) {
 105   FSM<State> fsm(State::A);
 106   int count = 0;
 107   fsm.updateState(State::B, State::A, [&]{ count++; });
 108   EXPECT_EQ(0, count);
 109 }
 110
 111 TEST(FSM, stateTransitionAfterAction) {
 112   FSM<State> fsm(State::A);
 113   fsm.updateState(State::A, State::B,
 114                   [&]{ EXPECT_EQ(State::A, fsm.getState()); });
 115 }