unittest_stop1_executor.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2019 Pilz GmbH & Co. KG
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <atomic>
#include <chrono>
#include <functional>
#include <memory>
#include <thread>

#include <gtest/gtest.h>
#include <gmock/gmock.h>

#include <ros/ros.h>

#include <pilz_testutils/async_test.h>

#include <prbt_hardware_support/stop1_executor.h>
#include <prbt_hardware_support/service_function_decl.h>

#define EXPECT_RECOVER                                       \
  EXPECT_CALL(*this, recover_func()) \
  .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(RECOVER_SRV_CALLED_EVENT), Return(true)))

#define EXPECT_UNHOLD                                       \
  EXPECT_CALL(*this, unhold_func()) \
  .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(UNHOLD_SRV_CALLED_EVENT), Return(true)))

#define EXPECT_HOLD                                       \
  EXPECT_CALL(*this, hold_func()) \
  .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(HOLD_SRV_CALLED_EVENT), Return(true)))

#define EXPECT_HALT                                       \
  EXPECT_CALL(*this, halt_func()) \
  .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(HALT_SRV_CALLED_EVENT), Return(true)))

namespace prbt_hardware_support_tests
{

using namespace prbt_hardware_support;

using ::testing::_;
using ::testing::DoAll;
using ::testing::InSequence;
using ::testing::Invoke;
using ::testing::InvokeWithoutArgs;
using ::testing::Return;
using ::testing::AtLeast;

const std::string RECOVER_SRV_CALLED_EVENT{"recover_srv_called"};
const std::string UNHOLD_SRV_CALLED_EVENT{"unhold_srv_called"};
const std::string HOLD_SRV_CALLED_EVENT{"hold_srv_called"};
const std::string HALT_SRV_CALLED_EVENT{"halt_srv_called"};

class Stop1ExecutorForTests : public Stop1Executor
{
public:
  Stop1ExecutorForTests(const TServiceCallFunc& hold_func,
                        const TServiceCallFunc& unhold_func,
                        const TServiceCallFunc& recover_func,
                        const TServiceCallFunc& halt_func)
    : Stop1Executor(hold_func, unhold_func, recover_func, halt_func)
  {
  }

  FRIEND_TEST(Stop1ExecutorTest, testExitInStateEnabling);
  FRIEND_TEST(Stop1ExecutorTest, testExitInStateStopping);
  FRIEND_TEST(Stop1ExecutorTest, testExitInStateEnableRequestDuringStop);
  FRIEND_TEST(Stop1ExecutorTest, testExitInStateStopRequestedDuringEnable);
};

class Stop1ExecutorTest : public ::testing::Test, public ::testing::AsyncTest
{
protected:
  Stop1ExecutorForTests* createStop1Executor();

public:
  MOCK_METHOD0(hold_func,     bool());
  MOCK_METHOD0(unhold_func,   bool());
  MOCK_METHOD0(recover_func,  bool());
  MOCK_METHOD0(halt_func,     bool());

};

inline Stop1ExecutorForTests* Stop1ExecutorTest::createStop1Executor()
{
  return new Stop1ExecutorForTests( std::bind(&Stop1ExecutorTest::hold_func,    this),
                                    std::bind(&Stop1ExecutorTest::unhold_func,  this),
                                    std::bind(&Stop1ExecutorTest::recover_func, this),
                                    std::bind(&Stop1ExecutorTest::halt_func,    this) );
}

TEST_F(Stop1ExecutorTest, testDestructor)
{
  {
    std::shared_ptr<Stop1Executor> adapter_run_permitted {new Stop1Executor( std::bind(&Stop1ExecutorTest::hold_func,    this),
                                                                             std::bind(&Stop1ExecutorTest::unhold_func,  this),
                                                                             std::bind(&Stop1ExecutorTest::recover_func, this),
                                                                             std::bind(&Stop1ExecutorTest::halt_func,    this) ) };
  }

  {
    Stop1Executor adapter_run_permitted( std::bind(&Stop1ExecutorTest::hold_func,    this),
                                         std::bind(&Stop1ExecutorTest::unhold_func,  this),
                                         std::bind(&Stop1ExecutorTest::recover_func, this),
                                         std::bind(&Stop1ExecutorTest::halt_func,    this) );
  }
}

TEST_F(Stop1ExecutorTest, testEnable)
{
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};
  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testEnableStopEnable)
{
  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};
  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;
    EXPECT_HOLD;
    EXPECT_HALT;
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});

  /**********
   * Step 3 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::atomic_bool keep_spamming{true};
  std::thread spam_enable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(true); } }};

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_enable.join();
}

TEST_F(Stop1ExecutorTest, testSpamEnablePlusStop)
{
  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  std::atomic_bool keep_spamming{true};
  std::thread spam_enable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(true); } }};

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_enable.join();

  /**********
   * Step 2 *
   **********/

  adapter_run_permitted->updateRunPermitted(true);

  /**********
   * Step 3 *
   **********/
  {
    InSequence dummy;
    EXPECT_HOLD;
    EXPECT_HALT;
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testSpamRunPermittedActivePlusEnable)
{
  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;
    EXPECT_HOLD;
    EXPECT_HALT;
  }

  std::atomic_bool keep_spamming{true};
  std::thread spam_disable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(false); } }};

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_disable.join();

  /**********
   * Step 3 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  keep_spamming = true;
  std::thread spam_enable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(true); } }};

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_enable.join();
}

TEST_F(Stop1ExecutorTest, testSkippingHoldPlusEnable)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for recover-invoke action
  auto run_permitted_false_during_recover_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(false);
    return true;
  };

  auto halt_action = [this]() {
    this->triggerClearEvent(HALT_SRV_CALLED_EVENT);
    return true;
  };

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_CALL(*this, recover_func())
        .WillOnce(InvokeWithoutArgs(run_permitted_false_during_recover_action));

    EXPECT_CALL(*this, halt_func())
        .WillOnce(InvokeWithoutArgs(halt_action));
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::atomic_bool keep_spamming{true};
  std::thread spam_enable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(true); } }};

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_enable.join();
}

TEST_F(Stop1ExecutorTest, testEnableDuringHoldService)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  auto enable_during_hold_action = [this, &adapter_run_permitted]() {
    adapter_run_permitted->updateRunPermitted(true);
    this->triggerClearEvent(HOLD_SRV_CALLED_EVENT);
    return true;
  };

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  {
    InSequence dummy;

    EXPECT_CALL(*this, hold_func())
        .WillOnce(InvokeWithoutArgs(enable_during_hold_action));

    EXPECT_HALT;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT, RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testEnableDuringHaltService)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for recover-invoke action
  auto run_permitted_false_during_recover_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(false);
    return true;
  };

  auto enable_during_halt_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(HALT_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(true);
    return true;
  };

  /**********
   * Step 1 *
   **********/

  const std::string RECOVER_SRV_CALLED_EVENT2{"recover_srv_called2"};
  const std::string UNHOLD_SRV_CALLED_EVENT2{"unhold_srv_called2"};
  {
    InSequence dummy;

    EXPECT_CALL(*this, recover_func())
        .WillOnce(InvokeWithoutArgs(run_permitted_false_during_recover_action));

    EXPECT_CALL(*this, halt_func())
        .WillOnce(InvokeWithoutArgs(enable_during_halt_action));

    EXPECT_CALL(*this, recover_func())
        .WillOnce(InvokeWithoutArgs([this, RECOVER_SRV_CALLED_EVENT2]() {
      this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT2);
      return true;
    }));

    EXPECT_CALL(*this, unhold_func())
        .WillOnce(InvokeWithoutArgs([this, UNHOLD_SRV_CALLED_EVENT2]() {
      this->triggerClearEvent(UNHOLD_SRV_CALLED_EVENT2);
      return true;
    }));
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT, RECOVER_SRV_CALLED_EVENT2, UNHOLD_SRV_CALLED_EVENT2});
}

TEST_F(Stop1ExecutorTest, testEnableDisableDuringHaltService)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for recover-invoke action
  auto run_permitted_false_during_recover_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(false);
    return true;
  };

  auto enable_during_halt_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(HALT_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(true);
    adapter_run_permitted->updateRunPermitted(false); // Important flip!
    return true;
  };

  /**********
   * Step 1 *
   **********/

  {
    InSequence dummy;

    EXPECT_CALL(*this, recover_func())
        .Times(1)
        .WillOnce(InvokeWithoutArgs(run_permitted_false_during_recover_action));

    EXPECT_CALL(*this, halt_func())
        .Times(1)
        .WillOnce(InvokeWithoutArgs(enable_during_halt_action));
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testRecoverFailPlusRetry)
{
  /**********
   * Step 1 *
   **********/
  EXPECT_CALL(*this, recover_func())
      .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(RECOVER_SRV_CALLED_EVENT), Return(false)))
      .WillRepeatedly(Return(false));

  // unhold is optional here
  EXPECT_CALL(*this, unhold_func())
      .WillRepeatedly(Return(true));

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;

    // hold and is_executing and is optional here
    EXPECT_CALL(*this, hold_func())
        .WillRepeatedly(Return(true));

    EXPECT_HALT;
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HALT_SRV_CALLED_EVENT});

  /**********
   * Step 3 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::atomic_bool keep_spamming{true};
  std::thread spam_enable{[&adapter_run_permitted, &keep_spamming]() { while (keep_spamming) { adapter_run_permitted->updateRunPermitted(true); } }};

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  keep_spamming = false;
  spam_enable.join();
}

TEST_F(Stop1ExecutorTest, testUnholdFail)
{
  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;

    EXPECT_CALL(*this, unhold_func())
        .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(UNHOLD_SRV_CALLED_EVENT), Return(false)))
        .WillRepeatedly(Return(false));
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};
  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;

    EXPECT_HOLD;
    EXPECT_HALT;
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testHoldFail)
{
  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;
    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  {
    InSequence dummy;

    EXPECT_CALL(*this, hold_func())
        .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(HOLD_SRV_CALLED_EVENT), Return(false)))
        .WillRepeatedly(Return(false));

    EXPECT_CALL(*this, halt_func())
        .WillOnce(DoAll(ACTION_OPEN_BARRIER_VOID(HALT_SRV_CALLED_EVENT), Return(false)))
        .WillRepeatedly(Return(false));
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testHoldImmediatelyAfterUnhold)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for unhold-invoke action
  auto unhold_action = [this, &adapter_run_permitted]() {
    this->triggerClearEvent(UNHOLD_SRV_CALLED_EVENT);
    adapter_run_permitted->updateRunPermitted(false);
    return true;
  };

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;

    EXPECT_CALL(*this, unhold_func())
        .WillOnce(InvokeWithoutArgs(unhold_action));

    EXPECT_HOLD;
    EXPECT_HALT;
  }

  adapter_run_permitted->updateRunPermitted(true);

  barricade({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT, HOLD_SRV_CALLED_EVENT, HALT_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testExitInStateEnabling)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for recover-invoke action
  auto recover_action = [this, &adapter_run_permitted]() {
    adapter_run_permitted->stopStateMachine();
    this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT);
    return true;
  };

  {
    InSequence dummy;

    EXPECT_CALL(*this, recover_func())
        .WillOnce(InvokeWithoutArgs(recover_action));

    // do not exclude other service calls as stopping the state machine does not prevent further actions
    EXPECT_CALL(*this, unhold_func())
        .WillRepeatedly(Return(true));
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testExitInStateStopping)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/
  // define function for hold-invoke action
  auto hold_action = [this, &adapter_run_permitted]() {
    adapter_run_permitted->stopStateMachine();
    this->triggerClearEvent(HOLD_SRV_CALLED_EVENT);
    return true;
  };

  {
    InSequence dummy;

    EXPECT_CALL(*this, hold_func())
        .WillOnce(InvokeWithoutArgs(hold_action));

    // do not exclude other service calls as stopping the state machine does not prevent further actions
    EXPECT_CALL(*this, halt_func())
        .WillRepeatedly(Return(true));
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER({HOLD_SRV_CALLED_EVENT});
}

TEST_F(Stop1ExecutorTest, testExitInStateStopRequestedDuringEnable)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  // define function for recover-invoke action
  auto recover_action = [this, &adapter_run_permitted]() {
    adapter_run_permitted->updateRunPermitted(false);
    adapter_run_permitted->stopStateMachine();
    this->triggerClearEvent(RECOVER_SRV_CALLED_EVENT);
    return true;
  };

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_CALL(*this, recover_func())
        .WillOnce(InvokeWithoutArgs(recover_action));

    // do not exclude other service calls as stopping the state machine does not prevent further actions
    EXPECT_CALL(*this, halt_func())
        .WillRepeatedly(Return(true));
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER(RECOVER_SRV_CALLED_EVENT);
}

TEST_F(Stop1ExecutorTest, testExitInStateEnableRequestDuringStop)
{
  std::unique_ptr<Stop1ExecutorForTests> adapter_run_permitted {createStop1Executor()};

  /**********
   * Step 1 *
   **********/
  {
    InSequence dummy;

    EXPECT_RECOVER;
    EXPECT_UNHOLD;
  }

  adapter_run_permitted->updateRunPermitted(true);

  BARRIER({RECOVER_SRV_CALLED_EVENT, UNHOLD_SRV_CALLED_EVENT});

  /**********
   * Step 2 *
   **********/

  auto enable_during_hold_action = [this, &adapter_run_permitted]() {
    adapter_run_permitted->updateRunPermitted(true);
    adapter_run_permitted->stopStateMachine();
    this->triggerClearEvent(HOLD_SRV_CALLED_EVENT);
    return true;
  };

  {
    InSequence dummy;

    EXPECT_CALL(*this, hold_func())
        .WillOnce(InvokeWithoutArgs(enable_during_hold_action));

    // do not exclude other service calls as stopping the state machine does not prevent further actions
    EXPECT_CALL(*this, halt_func())
        .WillRepeatedly(Return(true));
    EXPECT_CALL(*this, recover_func())
        .WillRepeatedly(Return(true));
    EXPECT_CALL(*this, unhold_func())
        .WillRepeatedly(Return(true));
  }

  adapter_run_permitted->updateRunPermitted(false);

  BARRIER(HOLD_SRV_CALLED_EVENT);
}


} // namespace prbt_hardware_support_tests

int main(int argc, char **argv)
{
  // for (limited) ros::Time functionality, no ROS communication
  ros::Time::init();

  testing::InitGoogleMock(&argc, argv);
  return RUN_ALL_TESTS();
}