unittest_modbus_adapter_operation_mode.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 <gtest/gtest.h>
#include <gmock/gmock.h>
#include <algorithm>
#include <memory>

#include <pilz_testutils/async_test.h>

#include <prbt_hardware_support/modbus_adapter_operation_mode.h>
#include <prbt_hardware_support/modbus_topic_definitions.h>
#include <prbt_hardware_support/OperationModes.h>
#include <prbt_hardware_support/register_container.h>
#include <prbt_hardware_support/modbus_msg_in_builder.h>

namespace prbt_hardware_support
{
static constexpr int DEFAULT_QUEUE_SIZE_MODBUS{1};
static const std::string SERVICE_NAME_OPERATION_MODE = "/prbt/get_operation_mode";
static const std::string TOPIC_OPERATION_MODE{"/prbt/operation_mode"};
static constexpr int OPERATION_MODE_QUEUE_SIZE{1};

static const std::string OPERATION_MODE_CALLBACK_EVENT{"operation_mode_callback_event"};

static constexpr unsigned int MODBUS_API_VERSION_REQUIRED{2};

static const ModbusApiSpec test_api_spec{ {modbus_api_spec::VERSION, 1},
                                          {modbus_api_spec::OPERATION_MODE, 11} };

static const std::vector<uint16_t> OPERATION_MODES{1, 2, 3};

class OperationModeSubscriberMock
{
public:
  void initialize();

  MOCK_METHOD1(callback, void(const OperationModesConstPtr& msg));

protected:
  ros::NodeHandle nh_;
  ros::Subscriber subscriber_;
};

void OperationModeSubscriberMock::initialize()
{
  subscriber_ = nh_.subscribe(TOPIC_OPERATION_MODE,
                              OPERATION_MODE_QUEUE_SIZE,
                              &OperationModeSubscriberMock::callback,
                              this);
}

using ::testing::StrictMock;

class ModbusAdapterOperationModeTest : public testing::Test, public testing::AsyncTest
{
public:
  ModbusAdapterOperationModeTest();
  virtual ~ModbusAdapterOperationModeTest();

protected:
  ros::AsyncSpinner spinner_{2};
  ros::NodeHandle nh_;
  std::shared_ptr<ModbusAdapterOperationMode> adapter_operation_mode_;
  ros::Publisher modbus_topic_pub_;
  ros::ServiceClient operation_mode_client_;
  StrictMock<OperationModeSubscriberMock> subscriber_;
};

ModbusAdapterOperationModeTest::ModbusAdapterOperationModeTest()
{
  // Initialize for ROS time if not already initialized
  if(!ros::Time::isValid())
  {
    ros::Time::init();
  }

  adapter_operation_mode_.reset(new ModbusAdapterOperationMode(nh_, test_api_spec));
  modbus_topic_pub_ = nh_.advertise<ModbusMsgInStamped>(TOPIC_MODBUS_READ, DEFAULT_QUEUE_SIZE_MODBUS);
  operation_mode_client_ = nh_.serviceClient<prbt_hardware_support::GetOperationMode>(SERVICE_NAME_OPERATION_MODE);

  spinner_.start();
}

ModbusAdapterOperationModeTest::~ModbusAdapterOperationModeTest()
{
  // Before the destructors of the class members are called, we have
  // to ensure that all topic and service calls done by the AsyncSpinner
  // threads are finished. Otherwise, we sporadically will see threading
  // exceptions like:
  // "boost::mutex::~mutex(): Assertion `!res' failed".
  spinner_.stop();
}

TEST_F(ModbusAdapterOperationModeTest, testAdapterOperationModeDtor)
{
  std::shared_ptr<AdapterOperationMode> adapter_op_mode (new AdapterOperationMode(nh_));
}

TEST_F(ModbusAdapterOperationModeTest, testModbusMsgOperationModeWrapperExceptionDtor)
{
  std::shared_ptr<ModbusMsgOperationModeWrapperException> ex (new ModbusMsgOperationModeWrapperException("Test message"));
}

TEST_F(ModbusAdapterOperationModeTest, testModbusMsgOperationModeWrapperDtor)
{
  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED).setOperationMode(OperationModes::T1);
  std::shared_ptr<ModbusMsgOperationModeWrapper> wrapper (new ModbusMsgOperationModeWrapper(builder.build(ros::Time::now()), test_api_spec));
}

MATCHER_P(IsExpectedOperationMode, exp_mode, "unexpected operation mode"){ return arg->value == exp_mode; }

TEST_F(ModbusAdapterOperationModeTest, testInitialOperationMode)
{
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  GetOperationMode srv;
  ASSERT_TRUE(operation_mode_client_.call(srv));
  EXPECT_EQ(OperationModes::UNKNOWN, srv.response.mode.value);
}

TEST_F(ModbusAdapterOperationModeTest, testMissingOperationModeRegister)
{
  /**********
   * Step 1 *
   **********/
  ROS_DEBUG("+++  Step 1 +++");
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 2 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::T1)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED);

  ROS_DEBUG("+++  Step 2 +++");
  modbus_topic_pub_.publish(builder.setOperationMode(OperationModes::T1).build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 3 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  ModbusMsgInStampedPtr msg {builder.setOperationMode(OperationModes::T1).build(ros::Time::now())};

  ROS_DEBUG("+++  Step 3 +++");
  // Remove operation mode from modbus message
  ASSERT_GT(test_api_spec.getRegisterDefinition(modbus_api_spec::OPERATION_MODE), test_api_spec.getRegisterDefinition(modbus_api_spec::VERSION))
      << "For the test to work correctly, the operation mode register has to be stored in the last register.";
  msg->holding_registers.data.erase(--msg->holding_registers.data.end());
  const uint32_t new_offset = test_api_spec.getRegisterDefinition(modbus_api_spec::VERSION);
  msg->holding_registers.layout.data_offset = new_offset;
  ModbusMsgInBuilder::setDefaultLayout(&(msg->holding_registers.layout), new_offset, static_cast<uint32_t>(msg->holding_registers.data.size()));

  modbus_topic_pub_.publish(msg);

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);
}

TEST_F(ModbusAdapterOperationModeTest, testOperationModeChange)
{
  /**********
   * Step 1 *
   **********/
  ROS_DEBUG("+++  Step 1 +++");
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 2 *
   **********/
  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED);
  for (const auto& mode : OPERATION_MODES)
  {
    EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(mode)))
      .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

    modbus_topic_pub_.publish(builder.setOperationMode(mode).build(ros::Time::now()));

    BARRIER(OPERATION_MODE_CALLBACK_EVENT);

    GetOperationMode srv;
    ASSERT_TRUE(operation_mode_client_.call(srv));
    EXPECT_EQ(mode, srv.response.mode.value);
  }
}

TEST_F(ModbusAdapterOperationModeTest, testDisconnect)
{
  /**********
   * Step 1 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 2 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::T1)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED).setOperationMode(OperationModes::T1);

  modbus_topic_pub_.publish(builder.build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 3 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  uint32_t offset{0};
  RegCont holding_register;
  ModbusMsgInStampedPtr msg{ModbusMsgInBuilder::createDefaultModbusMsgIn(offset, holding_register)};
  msg->disconnect.data = true;
  modbus_topic_pub_.publish(msg);

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);
}

TEST_F(ModbusAdapterOperationModeTest, testModbusUnexpectedOperationMode)
{
  /**********
   * Step 1 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 2 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::T1)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED).setOperationMode(OperationModes::T1);

  modbus_topic_pub_.publish(builder.build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 3 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED).setOperationMode(1234 /* stupid value */);
  modbus_topic_pub_.publish(builder.build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);
}

TEST_F(ModbusAdapterOperationModeTest, testModbusIncorrectApiVersion)
{
  /**********
   * Step 0 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  subscriber_.initialize();

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 1 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::T1)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  ModbusMsgInBuilder builder(test_api_spec);
  builder.setApiVersion(MODBUS_API_VERSION_REQUIRED).setOperationMode(OperationModes::T1);

  modbus_topic_pub_.publish(builder.build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);

  /**********
   * Step 2 *
   **********/
  EXPECT_CALL(subscriber_, callback(IsExpectedOperationMode(OperationModes::UNKNOWN)))
    .WillOnce(ACTION_OPEN_BARRIER_VOID(OPERATION_MODE_CALLBACK_EVENT));

  builder.setApiVersion(0 /* wrong version */).setOperationMode(OperationModes::T2);
  modbus_topic_pub_.publish(builder.build(ros::Time::now()));

  BARRIER(OPERATION_MODE_CALLBACK_EVENT);
}

} // namespace prbt_hardware_support

int main(int argc, char *argv[])
{
  ros::init(argc, argv, "unittest_modbus_adapter_operation_mode");
  ros::NodeHandle nh;

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