unittest_modbus_adapter_run_permitted.cpp

Go to the documentation of this file.

/*
 * Copyright (c) 2018 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 <string>
#include <vector>
#include <stdexcept>
#include <memory>
#include <functional>

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

#include <prbt_hardware_support/modbus_api_spec.h>
#include <prbt_hardware_support/param_names.h>
#include <prbt_hardware_support/ModbusMsgInStamped.h>
#include <prbt_hardware_support/modbus_msg_run_permitted_wrapper.h>
#include <prbt_hardware_support/modbus_msg_in_builder.h>
#include <prbt_hardware_support/modbus_adapter_run_permitted.h>
#include <prbt_hardware_support/register_container.h>

namespace prbt_hardware_support
{
static constexpr uint16_t RUN_PERMITTED_INVALID_VALUE{ 2 };

static const ModbusApiSpec TEST_API_SPEC{ { modbus_api_spec::VERSION, 513 }, { modbus_api_spec::RUN_PERMITTED, 512 } };

using namespace prbt_hardware_support;
using namespace modbus_api::v3;

using std::placeholders::_1;

class ModbusAdapterRunPermittedTest : public ::testing::Test
{
public:
  ModbusMsgInStampedPtr createDefaultRunPermittedModbusMsg(uint16_t run_permitted_clear);

public:
  MOCK_METHOD1(sendRunPermittedUpdate, void(const bool run_permitted));
};

ModbusMsgInStampedPtr ModbusAdapterRunPermittedTest::createDefaultRunPermittedModbusMsg(uint16_t run_permitted)
{
  static int msg_time_counter{ 1 };
  RegCont tab_reg(TEST_API_SPEC.size());
  tab_reg[0] = run_permitted;
  tab_reg[1] = MODBUS_API_VERSION_REQUIRED;
  ModbusMsgInStampedPtr msg{ ModbusMsgInBuilder::createDefaultModbusMsgIn(TEST_API_SPEC.getMinRegisterDefinition(),
                                                                          tab_reg) };
  msg->header.stamp = ros::Time(msg_time_counter++);
  return msg;
}

TEST_F(ModbusAdapterRunPermittedTest, testModbusMsgWrapperExceptionDtor)
{
  std::shared_ptr<ModbusMsgWrapperException> es{ new ModbusMsgWrapperException("Test msg") };
}

TEST_F(ModbusAdapterRunPermittedTest, testModbusMsgRunPermittedWrapperDtor)
{
  ModbusMsgInStampedConstPtr msg_const_ptr{ createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_TRUE) };
  std::shared_ptr<ModbusMsgRunPermittedWrapper> ex{ new ModbusMsgRunPermittedWrapper(msg_const_ptr, TEST_API_SPEC) };
}

TEST_F(ModbusAdapterRunPermittedTest, testRunPermittedClearMsg)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(true)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };
  run_permitted_adapter.modbusMsgCallback(createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_TRUE));
}

TEST_F(ModbusAdapterRunPermittedTest, testRunPermittedActiveMsg)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };
  run_permitted_adapter.modbusMsgCallback(createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE));
}

TEST_F(ModbusAdapterRunPermittedTest, testRunPermittedInvalidMsg)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };
  run_permitted_adapter.modbusMsgCallback(createDefaultRunPermittedModbusMsg(RUN_PERMITTED_INVALID_VALUE));
}

TEST_F(ModbusAdapterRunPermittedTest, testDisconnectNoRunPermittedMsg)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_TRUE);
  msg->disconnect.data = true;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testDisconnectWithRunPermittedMsg)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->disconnect.data = true;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testDisconnectPure)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg(new ModbusMsgInStamped());
  ros::Time::init();
  msg->header.stamp = ros::Time::now();
  msg->disconnect.data = true;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testNoVersion)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->holding_registers.data.pop_back();
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testWrongVersion)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->holding_registers.data[1] = 0;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testVersion1)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->holding_registers.data[1] = 1;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testVersion2)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->holding_registers.data[1] = 2;
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, testNoRunPermitted)
{
  EXPECT_CALL(*this, sendRunPermittedUpdate(false)).Times(1);

  ModbusAdapterRunPermitted run_permitted_adapter{ ModbusAdapterRunPermitted(
      std::bind(&ModbusAdapterRunPermittedTest::sendRunPermittedUpdate, this, _1), TEST_API_SPEC) };

  ModbusMsgInStampedPtr msg = createDefaultRunPermittedModbusMsg(MODBUS_RUN_PERMITTED_FALSE);
  msg->holding_registers.data.erase(msg->holding_registers.data.begin());
  msg->holding_registers.layout.data_offset = TEST_API_SPEC.getRegisterDefinition(modbus_api_spec::VERSION);
  run_permitted_adapter.modbusMsgCallback(msg);
}

TEST_F(ModbusAdapterRunPermittedTest, ModbusMsgExceptionCTOR)
{
  std::shared_ptr<ModbusMsgRunPermittedStatusMissing> exception_ptr{ new ModbusMsgRunPermittedStatusMissing("test") };
}

}  // namespace prbt_hardware_support

int main(int argc, char** argv)
{
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}