test_exceptions.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <string>
#include <type_traits>
#include <array>
#include "profinet/exceptions.h"
 
namespace profinet
{
 
// ============================================================================
// Exception Hierarchy Tests
// ============================================================================
 
TEST(ExceptionHierarchyTests, DcpErrorInheritsProfinetError)
{
  EXPECT_TRUE((std::is_base_of_v<ProfinetError, DCPError>));
}
 
TEST(ExceptionHierarchyTests, DcpTimeoutInheritsDcpError)
{
  EXPECT_TRUE((std::is_base_of_v<DCPError, DCPTimeoutError>));
}
 
TEST(ExceptionHierarchyTests, DcpDeviceNotFoundInheritsDcpError)
{
  EXPECT_TRUE((std::is_base_of_v<DCPError, DCPDeviceNotFoundError>));
}
 
TEST(ExceptionHierarchyTests, RpcErrorInheritsProfinetError)
{
  EXPECT_TRUE((std::is_base_of_v<ProfinetError, RPCError>));
}
 
TEST(ExceptionHierarchyTests, RpcTimeoutInheritsRpcError)
{
  EXPECT_TRUE((std::is_base_of_v<RPCError, RPCTimeoutError>));
}
 
TEST(ExceptionHierarchyTests, RpcFaultInheritsRpcError)
{
  EXPECT_TRUE((std::is_base_of_v<RPCError, RPCFaultError>));
}
 
TEST(ExceptionHierarchyTests, RpcConnectionInheritsRpcError)
{
  EXPECT_TRUE((std::is_base_of_v<RPCError, RPCConnectionError>));
}
 
TEST(ExceptionHierarchyTests, ValidationErrorInheritsProfinetError)
{
  EXPECT_TRUE((std::is_base_of_v<ProfinetError, ValidationError>));
}
 
TEST(ExceptionHierarchyTests, InvalidMacInheritsValidationError)
{
  EXPECT_TRUE((std::is_base_of_v<ValidationError, InvalidMACError>));
}
 
TEST(ExceptionHierarchyTests, InvalidIpInheritsValidationError)
{
  EXPECT_TRUE((std::is_base_of_v<ValidationError, InvalidIPError>));
}
 
TEST(ExceptionHierarchyTests, SocketErrorInheritsProfinetError)
{
  EXPECT_TRUE((std::is_base_of_v<ProfinetError, SocketError>));
}
 
TEST(ExceptionHierarchyTests, PermissionDeniedInheritsSocketError)
{
  EXPECT_TRUE((std::is_base_of_v<SocketError, PermissionDeniedError>));
}
 
// ============================================================================
// RPCFaultError Tests
// ============================================================================
 
TEST(RPCFaultErrorTests, FaultCodeDefault)
{
  const RPCFaultError error("test error");
  EXPECT_EQ(error.faultCode, 0U);
}
 
TEST(RPCFaultErrorTests, FaultCodeCustom)
{
  const RPCFaultError error("test error", 42);
  EXPECT_EQ(error.faultCode, 42U);
}
 
TEST(RPCFaultErrorTests, Message)
{
  const RPCFaultError error("RPC fault occurred");
  EXPECT_STREQ(error.what(), "RPC fault occurred");
}
 
// ============================================================================
// Exception Catching Tests
// ============================================================================
 
TEST(ExceptionCatchingTests, CatchAllProfinetErrors)
{
  EXPECT_THROW(throw DCPError("dcp"), ProfinetError);
  EXPECT_THROW(throw RPCError("rpc"), ProfinetError);
  EXPECT_THROW(throw ValidationError("validation"), ProfinetError);
  EXPECT_THROW(throw SocketError("socket"), ProfinetError);
}
 
TEST(ExceptionCatchingTests, CatchDcpVariants)
{
  EXPECT_THROW(throw DCPTimeoutError("timeout"), DCPError);
  EXPECT_THROW(throw DCPDeviceNotFoundError("not found"), DCPError);
}
 
TEST(ExceptionCatchingTests, CatchRpcVariants)
{
  EXPECT_THROW(throw RPCTimeoutError("timeout"), RPCError);
  EXPECT_THROW(throw RPCFaultError("fault"), RPCError);
  EXPECT_THROW(throw RPCConnectionError("connection"), RPCError);
  EXPECT_THROW(throw PNIOError("pnio", 0, 0, 0, 0), RPCError);
}
 
// ============================================================================
// PNIOError Tests
// ============================================================================
 
TEST(PNIOErrorTests, PnioErrorInheritsRpcError)
{
  EXPECT_TRUE((std::is_base_of_v<RPCError, PNIOError>));
}
 
TEST(PNIOErrorTests, DefaultValues)
{
  const PNIOError error("test error", 0, 0, 0, 0);
  EXPECT_EQ(error.errorCode, 0);
  EXPECT_EQ(error.errorDecode, 0);
  EXPECT_EQ(error.errorCode1, 0);
  EXPECT_EQ(error.errorCode2, 0);
}
 
TEST(PNIOErrorTests, CustomValues)
{
  const PNIOError error("test", 0xDE, 0x80, 0xB2, 0x07);
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB2);
  EXPECT_EQ(error.errorCode2, 0x07);
}
 
TEST(PNIOErrorTests, FromArgsStatusInvalidSlot)
{
  // Wire bytes [0x07, 0xB2, 0x80, 0xDE] -> big-endian 0x07B280DE -> swap -> 0xDE80B207
  constexpr std::uint32_t argsStatus = 0x07B280DE;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB2);
  EXPECT_EQ(error.errorCode2, 0x07);
  EXPECT_NE(std::string(error.what()).find("Invalid slot number"), std::string::npos);
}
 
TEST(PNIOErrorTests, FromArgsStatusInvalidSubslot)
{
  // Wire bytes [0x08, 0xB2, 0x80, 0xDE] -> big-endian 0x08B280DE -> swap -> 0xDE80B208
  constexpr std::uint32_t argsStatus = 0x08B280DE;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB2);
  EXPECT_EQ(error.errorCode2, 0x08);
  EXPECT_NE(std::string(error.what()).find("Invalid subslot number"), std::string::npos);
}
 
TEST(PNIOErrorTests, FromArgsStatusInvalidIndex)
{
  // Wire bytes [0x00, 0xB0, 0x80, 0xDE] -> big-endian 0x00B080DE -> swap -> 0xDE80B000
  constexpr std::uint32_t argsStatus = 0x00B080DE;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB0);
  EXPECT_EQ(error.errorCode2, 0x00);
  EXPECT_NE(std::string(error.what()).find("Index not supported"), std::string::npos);
}
 
TEST(PNIOErrorTests, FromArgsStatusInvalidApi)
{
  // Wire bytes [0x06, 0xB4, 0x80, 0xDE] -> big-endian 0x06B480DE -> swap -> 0xDE80B406
  constexpr std::uint32_t argsStatus = 0x06B480DE;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB4);
  EXPECT_EQ(error.errorCode2, 0x06);
  EXPECT_NE(std::string(error.what()).find("Invalid API number"), std::string::npos);
}
 
TEST(PNIOErrorTests, FromArgsStatusRmpmError)
{
  // Matches Hilscher PNIO_E_RMPM_CONNECT_UNKNOWN_BLOCKS = 0xDB814001
  // Wire bytes [0x01, 0x40, 0x81, 0xDB] -> big-endian 0x014081DB -> swap -> 0xDB814001
  constexpr std::uint32_t argsStatus = 0x014081DB;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDB);   // IODConnectRes
  EXPECT_EQ(error.errorDecode, 0x81); // PNIO
  EXPECT_EQ(error.errorCode1, 0x40);  // RMPM
  EXPECT_EQ(error.errorCode2, 0x01);  // Unknown blocks
  EXPECT_NE(std::string(error.what()).find("Unknown blocks in request"), std::string::npos);
}
 
TEST(PNIOErrorTests, FromArgsStatusUnknownError)
{
  // Wire bytes [0xFF, 0xB2, 0x80, 0xDE] -> big-endian 0xFFB280DE -> swap -> 0xDE80B2FF
  constexpr std::uint32_t argsStatus = 0xFFB280DE;
  const auto error = PNIOError::FromArgsStatus(argsStatus);
 
  EXPECT_EQ(error.errorCode, 0xDE);
  EXPECT_EQ(error.errorCode2, 0xFF);
  EXPECT_NE(std::string(error.what()).find("Unknown"), std::string::npos);
}
 
TEST(PNIOErrorTests, StrFormat)
{
  const PNIOError error("Test message", 0xDE, 0x80, 0xB2, 0x07);
  const std::string result = error.what();
  EXPECT_NE(result.find("Test message"), std::string::npos);
}
 
TEST(PNIOErrorTests, ErrorConstants)
{
  EXPECT_EQ(ErrorDecode::PnioCm, static_cast<ErrorDecode>(0x40));
  EXPECT_EQ(ErrorDecode::PnioRw, static_cast<ErrorDecode>(0x80));
  EXPECT_EQ(ErrorDecode::Pnio, static_cast<ErrorDecode>(0x81));
  EXPECT_EQ(PnioRwErrorCode1::InvalidIndex, static_cast<PnioRwErrorCode1>(0xB0));
  EXPECT_EQ(PnioRwErrorCode1::Resource, static_cast<PnioRwErrorCode1>(0xB2));
  EXPECT_EQ(PnioRwErrorCode1::Application, static_cast<PnioRwErrorCode1>(0xB4));
}
 
// ============================================================================
// PNIOError::CreateFromCodes() — PNIO-CM
// ============================================================================
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmAr)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x01);
  EXPECT_EQ(error.errorCode2, 0x00);
  EXPECT_EQ(std::string(error.what()), "Invalid AR type");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmArResponse)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x81, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x81);
  EXPECT_EQ(error.errorCode2, 0x00);
  EXPECT_EQ(std::string(error.what()), "Invalid AR type (in response)");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmIocr)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x02, 0x04};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Invalid IO data length");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmIocrResponse)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x82, 0x04};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Invalid IO data length (in response)");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmAlarmCr)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x03, 0x01};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Out of AlarmCR resources");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmAlarmCrResponse)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x83, 0x01};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Out of AlarmCR resources (in response)");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmExpectedSubmodule)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x04, 0x04};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "IO data length mismatch");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmDevice)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x3F, 0x02};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Device already owned");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmFaultyBlock)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0xFF, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Faulty block structure");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioCmUnknownErrorCode1)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x0A, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Unknown CM error in Unknown (0x0A)");
}
 
// ============================================================================
// PNIOError::CreateFromCodes() — PNIO
// ============================================================================
 
TEST(PNIOErrorTests, CreateFromCodesPnioRmpm)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x81, 0x40, 0x02};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x81);
  EXPECT_EQ(error.errorCode1, 0x40);
  EXPECT_EQ(error.errorCode2, 0x02);
  EXPECT_EQ(std::string(error.what()), "Required IOCR block missing");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioPrmServer)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x81, 0x3D, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Parameter server state conflict");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioUnknownErrorCode1)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x81, 0x0A, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Unknown PNIO error");
}
 
// ============================================================================
// PNIOError::CreateFromCodes() — PNIORW
// ============================================================================
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwInvalidIndex)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB0, 0x05};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()),
            "Index exists but has not been written");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwWriteLength)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB1, 0x03};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()),
            "Write access denied (write protected)");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwResource)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB2, 0x08};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Invalid subslot number");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwAccess)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB3, 0x05};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()),
            "Access denied (invalid state for access)");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwApplication)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB4, 0x08};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Alarm pending");
}
 
TEST(PNIOErrorTests, CreateFromCodesPnioRwUnknownErrorCode1)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0x0A, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(std::string(error.what()), "Unknown PNIORW error");
}
 
// ============================================================================
// PNIOError::CreateFromCodes() — unknown ErrorDecode
// ============================================================================
 
TEST(PNIOErrorTests, CreateFromCodesUnknownErrorDecode)
{
  const std::array<std::uint8_t, 4> data{
      0x12, 0x7F, 0x34, 0x56};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, 0x12);
  EXPECT_EQ(error.errorDecode, 0x7F);
  EXPECT_EQ(error.errorCode1, 0x34);
  EXPECT_EQ(error.errorCode2, 0x56);
  EXPECT_EQ(std::string(error.what()), "Unknown error (Decode=0x7F)");
}
 
// ============================================================================
// Raw byte preservation
// ============================================================================
 
TEST(PNIOErrorTests, FromBytesPreservesAllRawErrorBytes)
{
  const std::array<std::uint8_t, 4> data{
      0xDA, 0x40, 0x03, 0x01};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, data[0]);
  EXPECT_EQ(error.errorDecode, data[1]);
  EXPECT_EQ(error.errorCode1, data[2]);
  EXPECT_EQ(error.errorCode2, data[3]);
}
 
TEST(PNIOErrorTests, FromBytesUsesExpectedByteOrder)
{
  const std::array<std::uint8_t, 4> data{
      0xAA, 0x40, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.errorCode, 0xAA);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x01);
  EXPECT_EQ(error.errorCode2, 0x00);
}
 
// ============================================================================
// FromArgsStatus
// ============================================================================
 
TEST(PNIOErrorTests, FromArgsStatusReversesByteOrder)
{
  // After the byte swap this becomes:
  //
  //   ErrorCode   = 0x01
  //   ErrorDecode = 0x02
  //   ErrorCode1  = 0x03
  //   ErrorCode2  = 0x04
  //
  // Therefore the input ArgsStatus must be 0x04030201.
  const auto error = PNIOError::FromArgsStatus(0x04030201U);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x02);
  EXPECT_EQ(error.errorCode1, 0x03);
  EXPECT_EQ(error.errorCode2, 0x04);
  EXPECT_EQ(std::string(error.what()), "Unknown error (Decode=0x02)");
}
 
TEST(PNIOErrorTests, FromArgsStatusDecodesPnioCmError)
{
  // Desired decoded bytes:
  //
  //   ErrorCode   = 0x01
  //   ErrorDecode = 0x40
  //   ErrorCode1  = 0x01
  //   ErrorCode2  = 0x00
  //
  // ArgsStatus therefore contains the reversed byte sequence.
  const auto error = PNIOError::FromArgsStatus(0x00014001U);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x01);
  EXPECT_EQ(error.errorCode2, 0x00);
  EXPECT_EQ(std::string(error.what()), "Invalid AR type");
}
 
// ============================================================================
// IsCmError
// ============================================================================
 
TEST(PNIOErrorTests, IsCmErrorReturnsTrueForPnioCm)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_TRUE(error.IsCmError());
}
 
TEST(PNIOErrorTests, IsCmErrorReturnsFalseForPnioRw)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB0, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_FALSE(error.IsCmError());
}
 
TEST(PNIOErrorTests, IsCmErrorReturnsFalseForPnio)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x81, 0x40, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_FALSE(error.IsCmError());
}
 
TEST(PNIOErrorTests, IsCmErrorReturnsFalseForUnknownDecode)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x7F, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_FALSE(error.IsCmError());
}
 
// ============================================================================
// BlockName
// ============================================================================
 
TEST(PNIOErrorTests, BlockNameReturnsArBlock)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.BlockName(), "AR Block");
}
 
TEST(PNIOErrorTests, BlockNameReturnsIocrBlock)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x02, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.BlockName(), "IOCR Block");
}
 
TEST(PNIOErrorTests, BlockNameReturnsArResponseBlock)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x81, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.BlockName(), "AR Block Response");
}
 
TEST(PNIOErrorTests, BlockNameReturnsUnknownForUnknownCmErrorCode1)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x40, 0x0A, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_EQ(error.BlockName(), "Unknown (0x0A)");
}
 
TEST(PNIOErrorTests, BlockNameReturnsEmptyForPnioRwError)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x80, 0xB0, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_TRUE(error.BlockName().empty());
}
 
TEST(PNIOErrorTests, BlockNameReturnsEmptyForPnioError)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x81, 0x40, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_TRUE(error.BlockName().empty());
}
 
TEST(PNIOErrorTests, BlockNameReturnsEmptyForUnknownDecode)
{
  const std::array<std::uint8_t, 4> data{
      0x01, 0x7F, 0x01, 0x00};
 
  const auto error = PNIOError::FromBytes(data);
 
  EXPECT_TRUE(error.BlockName().empty());
}
 
// ============================================================================
// Direct PNIOError construction
// ============================================================================
 
TEST(PNIOErrorTests, DirectConstructionPreservesMessageAndCodes)
{
  const PNIOError error{
      "test error",
      0xDA,
      0x40,
      0x03,
      0x01};
 
  EXPECT_EQ(std::string(error.what()), "test error");
  EXPECT_EQ(error.errorCode, 0xDA);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x03);
  EXPECT_EQ(error.errorCode2, 0x01);
}
 
TEST(PNIOErrorTests, DirectConstructionIsCmError)
{
  const PNIOError error{
      "test error",
      0x01,
      0x40,
      0x01,
      0x00};
 
  EXPECT_TRUE(error.IsCmError());
}
 
TEST(PNIOErrorTests, DirectConstructionIsNotCmError)
{
  const PNIOError error{
      "test error",
      0x01,
      0x81,
      0x40,
      0x00};
 
  EXPECT_FALSE(error.IsCmError());
}
class PNIOErrorDirectTests : public ::testing::Test
{
 protected:
  static PNIOError CreateFromCodes(
      const std::uint8_t errorCode,
      const std::uint8_t errorDecode,
      const std::uint8_t errorCode1,
      const std::uint8_t errorCode2)
  {
    return PNIOError::CreateFromCodes(
        errorCode,
        errorDecode,
        errorCode1,
        errorCode2);
  }
 
  static std::string DecodePnioCm(
      const std::uint8_t errorCode1,
      const std::uint8_t errorCode2)
  {
    return PNIOError::DecodePnioCmError(errorCode1, errorCode2);
  }
 
  static std::string DecodePnio(
      const std::uint8_t errorCode1,
      const std::uint8_t errorCode2)
  {
    return PNIOError::DecodePnioError(errorCode1, errorCode2);
  }
 
  static std::string DecodePnioRw(
      const std::uint8_t errorCode1,
      const std::uint8_t errorCode2)
  {
    return PNIOError::DecodePnioRWError(errorCode1, errorCode2);
  }
};
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmAr)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x01,
      0x00);
 
  EXPECT_EQ(error.errorCode, 0x01);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x01);
  EXPECT_EQ(error.errorCode2, 0x00);
  EXPECT_EQ(std::string(error.what()), "Invalid AR type");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmArResponse)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x81,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Invalid AR type (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmIocr)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x02,
      0x04);
 
  EXPECT_EQ(std::string(error.what()), "Invalid IO data length");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmIocrResponse)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x82,
      0x04);
 
  EXPECT_EQ(std::string(error.what()), "Invalid IO data length (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmAlarmCr)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x03,
      0x01);
 
  EXPECT_EQ(std::string(error.what()), "Out of AlarmCR resources");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmAlarmCrResponse)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x83,
      0x01);
 
  EXPECT_EQ(std::string(error.what()), "Out of AlarmCR resources (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmExpectedSubmodule)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x04,
      0x04);
 
  EXPECT_EQ(std::string(error.what()), "IO data length mismatch");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmDevice)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x3F,
      0x02);
 
  EXPECT_EQ(std::string(error.what()), "Device already owned");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmFaultyBlock)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0xFF,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Faulty block structure");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmUnknownErrorCode1)
{
  const auto error = CreateFromCodes(
      0x01,
      0x40,
      0x0A,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Unknown CM error in Unknown (0x0A)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRmpm)
{
  const auto error = CreateFromCodes(
      0x01,
      0x81,
      0x40,
      0x02);
 
  EXPECT_EQ(std::string(error.what()), "Required IOCR block missing");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioPrmServer)
{
  const auto error = CreateFromCodes(
      0x01,
      0x81,
      0x3D,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Parameter server state conflict");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioUnknownErrorCode1)
{
  const auto error = CreateFromCodes(
      0x01,
      0x81,
      0x0A,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Unknown PNIO error");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwInvalidIndex)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0xB0,
      0x05);
 
  EXPECT_EQ(std::string(error.what()), "Index exists but has not been written");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwWriteLength)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0xB1,
      0x03);
 
  EXPECT_EQ(std::string(error.what()), "Write access denied (write protected)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwResource)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0xB2,
      0x08);
 
  EXPECT_EQ(std::string(error.what()), "Invalid subslot number");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwAccess)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0xB3,
      0x05);
 
  EXPECT_EQ(std::string(error.what()), "Access denied (invalid state for access)");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwApplication)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0xB4,
      0x08);
 
  EXPECT_EQ(std::string(error.what()), "Alarm pending");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwUnknownErrorCode1)
{
  const auto error = CreateFromCodes(
      0x01,
      0x80,
      0x0A,
      0x00);
 
  EXPECT_EQ(std::string(error.what()), "Unknown PNIORW error");
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioCmPreservesRawCodes)
{
  const auto error = CreateFromCodes(
      0xDA,
      0x40,
      0x03,
      0x01);
 
  EXPECT_EQ(error.errorCode, 0xDA);
  EXPECT_EQ(error.errorDecode, 0x40);
  EXPECT_EQ(error.errorCode1, 0x03);
  EXPECT_EQ(error.errorCode2, 0x01);
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioRwPreservesRawCodes)
{
  const auto error = CreateFromCodes(
      0xCF,
      0x80,
      0xB3,
      0x06);
 
  EXPECT_EQ(error.errorCode, 0xCF);
  EXPECT_EQ(error.errorDecode, 0x80);
  EXPECT_EQ(error.errorCode1, 0xB3);
  EXPECT_EQ(error.errorCode2, 0x06);
}
 
TEST_F(PNIOErrorDirectTests, DirectCreateFromCodesPnioPreservesRawCodes)
{
  const auto error = CreateFromCodes(
      0xDB,
      0x81,
      0x40,
      0x04);
 
  EXPECT_EQ(error.errorCode, 0xDB);
  EXPECT_EQ(error.errorDecode, 0x81);
  EXPECT_EQ(error.errorCode1, 0x40);
  EXPECT_EQ(error.errorCode2, 0x04);
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorAr)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::Ar), 0x00), "Invalid AR type");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorArResponse)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::ArResponse), 0x00), "Invalid AR type (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorArActive)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::Ar), 0x01), "AR already active");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorArActiveResponse)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::ArResponse), 0x01), "AR already active (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorNoArResources)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::NoArResources), "Out of AR resources");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorNoProviderResources)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::NoProviderResources), "Out of provider resources");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorNoConsumerResources)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::NoConsumerResources), "Out of consumer resources");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorNoAlarmResources)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::NoAlarmResources), "Out of alarm resources");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorNoMemory)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::NoMemory), "Out of memory");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorInvalidSessionKey)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::InvalidSessionKey), "Invalid session key");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorArUuidConflict)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2::ArUuidConflict), "AR UUID conflict");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmArErrorUnknownCode2)
{
  EXPECT_EQ(GetPnioCmErrorMessage(PnioCmArErrorCode2{0xFF}), "Unknown Error (0xFF)");
}
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorIocr)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::Iocr), 0x04), "Invalid IO data length");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorIocrResponse)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::IocrResponse), 0x04), "Invalid IO data length (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorAlarmCr)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::AlarmCr), 0x01), "Out of AlarmCR resources");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorAlarmCrResponse)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::AlarmCrResponse), 0x01), "Out of AlarmCR resources (in response)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorExpectedSubmodule)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::ExpectedSubmodule), 0x04), "IO data length mismatch");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorDevice)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::CmDev), 0x02), "Device already owned");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorFaultyBlock)
{
  EXPECT_EQ(DecodePnioCm(static_cast<std::uint8_t>(PnioCmErrorCode1::FaultyBlock), 0x00), "Faulty block structure");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioCmErrorUnknownCode1)
{
  EXPECT_EQ(DecodePnioCm(0x0A, 0x00), "Unknown CM error in Unknown (0x0A)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioErrorRmpm)
{
  EXPECT_EQ(DecodePnio(static_cast<std::uint8_t>(PnioErrorCode1::Rmpm), 0x02), "Required IOCR block missing");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioErrorPrmServer)
{
  EXPECT_EQ(DecodePnio(static_cast<std::uint8_t>(PnioErrorCode1::PrmServer), 0x00), "Parameter server state conflict");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioErrorUnknownCode1)
{
  EXPECT_EQ(DecodePnio(0x0A, 0x00), "Unknown PNIO error");
}
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorInvalidIndex)
{
  EXPECT_EQ(DecodePnioRw(static_cast<std::uint8_t>(PnioRwErrorCode1::InvalidIndex), 0x05), "Index exists but has not been written");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorWriteLength)
{
  EXPECT_EQ(DecodePnioRw(static_cast<std::uint8_t>(PnioRwErrorCode1::WriteLength), 0x03), "Write access denied (write protected)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorResource)
{
  EXPECT_EQ(DecodePnioRw(static_cast<std::uint8_t>(PnioRwErrorCode1::Resource), 0x08), "Invalid subslot number");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorAccess)
{
  EXPECT_EQ(DecodePnioRw(static_cast<std::uint8_t>(PnioRwErrorCode1::Access), 0x05), "Access denied (invalid state for access)");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorApplication)
{
  EXPECT_EQ(DecodePnioRw(static_cast<std::uint8_t>(PnioRwErrorCode1::Application), 0x08), "Alarm pending");
}
 
TEST_F(PNIOErrorDirectTests, DecodePnioRwErrorUnknownCode1)
{
  EXPECT_EQ(DecodePnioRw(0x0A, 0x00), "Unknown PNIORW error");
}
} // namespace profinet