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::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 {
  55     FSM<State> fsm_;
  56     int count = 0;
  57     int unprotectedCount = 0;
  58     MyFSM() : fsm_(State::A) {}
  59     void twiddle() {
  60       FSM_START(fsm_)
  61         FSM_CASE(fsm_, State::A, State::B, [&]{ count++; });
  62         FSM_CASE2(fsm_, State::B, State::A,
  63                   [&]{ count--; }, [&]{ unprotectedCount--; });
  64       FSM_END
  65     }
  66   };
  67
  68   MyFSM fsm;
  69
  70   fsm.twiddle();
  71   EXPECT_EQ(State::B, fsm.fsm_.getState());
  72   EXPECT_EQ(1, fsm.count);
  73   EXPECT_EQ(0, fsm.unprotectedCount);
  74
  75   fsm.twiddle();
  76   EXPECT_EQ(State::A, fsm.fsm_.getState());
  77   EXPECT_EQ(0, fsm.count);
  78   EXPECT_EQ(-1, fsm.unprotectedCount);
  79 }
  80
  81
  82 TEST(FSM, ctor) {
  83   FSM<State> fsm(State::A);
  84   EXPECT_EQ(State::A, fsm.getState());
  85 }
  86
  87 TEST(FSM, update) {
  88   FSM<State> fsm(State::A);
  89   EXPECT_TRUE(fsm.updateState(State::A, State::B, []{}));
  90   EXPECT_EQ(State::B, fsm.getState());
  91 }
  92
  93 TEST(FSM, badUpdate) {
  94   FSM<State> fsm(State::A);
  95   EXPECT_FALSE(fsm.updateState(State::B, State::A, []{}));
  96 }
  97
  98 TEST(FSM, actionOnUpdate) {
  99   FSM<State> fsm(State::A);
 100   int count = 0;
 101   fsm.updateState(State::A, State::B, [&]{ count++; });
 102   EXPECT_EQ(1, count);
 103 }
 104
 105 TEST(FSM, noActionOnBadUpdate) {
 106   FSM<State> fsm(State::A);
 107   int count = 0;
 108   fsm.updateState(State::B, State::A, [&]{ count++; });
 109   EXPECT_EQ(0, count);
 110 }
 111
 112 TEST(FSM, stateTransitionAfterAction) {
 113   FSM<State> fsm(State::A);
 114   fsm.updateState(State::A, State::B,
 115                   [&]{ EXPECT_EQ(State::A, fsm.getState()); });
 116 }