OpENeruCPort/OrginalSourceRepo/OpENer-master/source/tests/cip/cipepathtest.cpp

/*******************************************************************************
 * Copyright (c) 2016, Rockwell Automation, Inc.
 * All rights reserved.
 *
 ******************************************************************************/

#include <CppUTest/TestHarness.h>
#include <stdint.h>
#include <string.h>

extern "C" {

#include "cipepath.h"

}

TEST_GROUP (CipEpath) {

};

/** Segment type tests **/
TEST(CipEpath, GetSegmentTypePortSegment) {
  const unsigned char message[] = {0x00};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypePortSegment, segment_type);
}

TEST(CipEpath, GetSegmentTypeLogicalSegment) {
  const unsigned char message[] = {0x20};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeLogicalSegment, segment_type);
}

TEST(CipEpath, GetSegmentTypeNetworkSegment) {
  const unsigned char message[] = {0x40};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeNetworkSegment, segment_type);
}

TEST(CipEpath, GetSegmentTypeSymbolicSegment) {
  const unsigned char message[] = {0x60};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeSymbolicSegment, segment_type);
}

TEST(CipEpath, GetSegmentTypeDataSegment) {
  const unsigned char message[] = {0x80};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeDataSegment, segment_type);
}

TEST(CipEpath, GetSegmentTypeDataTypeConstructed) {
  const unsigned char message[] = {0xA0};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeDataTypeConstructed, segment_type);
}

TEST(CipEpath, GetSegmentTypeDataTypeElementary) {
  const unsigned char message[] = {0xC0};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeDataTypeElementary, segment_type);
}

TEST(CipEpath, GetSegmentTypeReserved) {
  const unsigned char message[] = {0xE0};
  SegmentType segment_type = GetPathSegmentType(message);
  CHECK_EQUAL(kSegmentTypeReserved, segment_type);
}
/* Set Segment Type tests*/
TEST(CipEpath, SetSegmentTypePortSegment) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypePortSegment, message);
  CHECK_EQUAL(0x00, message[0]);
}

TEST(CipEpath, SetSegmentTypeLogicalSegment) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeLogicalSegment, message);
  CHECK_EQUAL(0x20, message[0]);
}

TEST(CipEpath, SetSegmentTypeNetworkSegment) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeNetworkSegment, message);
  CHECK_EQUAL(0x40, message[0]);
}

TEST(CipEpath, SetSegmentTypeSymbolicSegment) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeSymbolicSegment, message);
  CHECK_EQUAL(0x60, message[0]);
}

TEST(CipEpath, SetSegmentTypeDataSegment) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeDataSegment, message);
  CHECK_EQUAL(0x80, message[0]);
}

TEST(CipEpath, SetSegmentTypeDataTypeConstructed) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeDataTypeConstructed, message);
  CHECK_EQUAL(0xA0, message[0]);
}

TEST(CipEpath, SetSegmentTypeDataTypeElementary) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeDataTypeElementary, message);
  CHECK_EQUAL(0xC0, message[0]);
}

TEST(CipEpath, SetSegmentTypeReserved) {
  unsigned char message[] = {0xFF};
  SetPathSegmentType(kSegmentTypeReserved, message);
  CHECK_EQUAL(0xE0, message[0]);
}

/** Port segment tests **/
TEST(CipEpath, GetPortSegmentExtendedAddressSizeTrue) {
  const unsigned char message[] = {0x10};
  bool extended_address = GetPathPortSegmentExtendedLinkAddressSizeBit(message);
  CHECK_EQUAL(true, extended_address);
}

TEST(CipEpath, GetPortSegmentExtendedAddressSizeFalse) {
  const unsigned char message[] = {0x00};
  bool extended_address = GetPathPortSegmentExtendedLinkAddressSizeBit(message);
  CHECK_EQUAL(false, extended_address);
}

TEST(CipEpath, GetPortSegmentPortIdentifier) {
  const unsigned char message[] = {0x0F};
  unsigned int port = GetPathPortSegmentPortIdentifier(message);
  unsigned int mes = (unsigned int)(message[0]);
  CHECK_EQUAL(15, mes);
}

TEST(CipEpath, SetPortSegmentPortIdentifier) {
  unsigned char message[] = {0x00};
  SetPathPortSegmentPortIdentifier(15, message);
  CHECK_EQUAL( 15, (unsigned int)(message[0]) );
}

TEST(CipEpath, GetPortSegmentLinkAddressSize) {
  const unsigned char message[] = {0x10,0x04};
  unsigned int size = GetPathPortSegmentLinkAddressSize(message);
  CHECK_EQUAL(4, size);
}

TEST(CipEpath, GetPortSegmentExtendedPortNumberNoExtendedAddress) {
  const unsigned char message[] = {0x0F, 0x22, 0x64};
  unsigned int extended_port = GetPathPortSegmentExtendedPortNumber(message);
  CHECK_EQUAL(25634, extended_port);
}

TEST(CipEpath, GetPortSegmentExtendedPortNumberWithExtendedAddress) {
  const unsigned char message[] = {0x1F, 0x00, 0x22, 0x64};
  unsigned int extended_port = GetPathPortSegmentExtendedPortNumber(message);
  CHECK_EQUAL(25634, extended_port);
}

TEST(CipEpath, SetPortSegmentExtendedPortNoExtendedAddress) {
  unsigned char message[] = {0x00, 0x00, 0x00};
  const char expected_message[] = {0x0F, 0x22, 0x64};
  SetPathPortSegmentExtendedPortIdentifier( (unsigned int)25634, message );
  MEMCMP_EQUAL(expected_message, message, 3);
}

TEST(CipEpath, SetPortSegmentExtendedPortWithExtendedAddress) {
  unsigned char message[] = {0x10, 0x00, 0x00, 0x00};
  const char expected_message[] = {0x1F, 0x00, 0x22, 0x64};
  SetPathPortSegmentExtendedPortIdentifier( (unsigned int)25634, message );
  MEMCMP_EQUAL(expected_message, message, 4);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeClassId) {
  const unsigned char message[] = {0x20};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeClassId, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeInstanceId) {
  const unsigned char message[] = {0x24};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeInstanceId, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeMemberId) {
  const unsigned char message[] = {0x28};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeMemberId, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeConnectionPoint) {
  const unsigned char message[] = {0x2C};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeConnectionPoint, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeAttributeId) {
  const unsigned char message[] = {0x30};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeAttributeId, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeSpecial) {
  const unsigned char message[] = {0x34};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeSpecial, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeServiceId) {
  const unsigned char message[] = {0x38};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeServiceId, type);
}

TEST(CipEpath, GetLogicalSegmentLogicalTypeExtendedLogical) {
  const unsigned char message[] = {0x3C};
  const LogicalSegmentLogicalType type = GetPathLogicalSegmentLogicalType(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalTypeExtendedLogical, type);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeClassId) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeClassId, message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_CLASS_ID,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeInstanceId) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeInstanceId,
                                   message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_INSTANCE_ID,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeMemberId) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeMemberId, message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_MEMBER_ID,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeConnectionPoint) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeConnectionPoint,
                                   message);
  CHECK_EQUAL(
    SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_CONNECTION_POINT,
    message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeAttributeId) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeAttributeId,
                                   message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_ATTRIBUTE_ID,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeSpecial) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeSpecial, message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_SPECIAL,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeServiceId) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeServiceId,
                                   message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_SERVICE_ID,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalTypeExtendedLogicalPath) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalType(kLogicalSegmentLogicalTypeExtendedLogical,
                                   message);
  CHECK_EQUAL(
    SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_TYPE_EXTENDED_LOGICAL,
    message[0]);
}

TEST(CipEpath, GetLogicalSegmentLogicalFormatEightBits) {
  const unsigned char message[] = {0x20};
  const LogicalSegmentLogicalFormat format = GetPathLogicalSegmentLogicalFormat(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalFormatEightBit, format);
}

TEST(CipEpath, GetLogicalSegmentLogicalFormatSixteenBits) {
  const unsigned char message[] = {0x21};
  const LogicalSegmentLogicalFormat format = GetPathLogicalSegmentLogicalFormat(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalFormatSixteenBit, format);
}

TEST(CipEpath, GetLogicalSegmentLogicalFormatThirtyTwoBits) {
  const unsigned char message[] = {0x22};
  const LogicalSegmentLogicalFormat format = GetPathLogicalSegmentLogicalFormat(
    message);
  CHECK_EQUAL(kLogicalSegmentLogicalFormatThirtyTwoBit, format);
}

TEST(CipEpath, SetLogicalSegmentLogicalFormatEightBits) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalFormat(kLogicalSegmentLogicalFormatEightBit,
                                     message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_FORMAT_EIGHT_BIT,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalFormatSixteenBits) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalFormat(kLogicalSegmentLogicalFormatSixteenBit,
                                     message);
  CHECK_EQUAL(SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT,
              message[0]);
}

TEST(CipEpath, SetLogicalSegmentLogicalFormatThirtyTwoBits) {
  CipOctet message[] = {SEGMENT_TYPE_LOGICAL_SEGMENT};
  SetPathLogicalSegmentLogicalFormat(kLogicalSegmentLogicalFormatThirtyTwoBit,
                                     message);
  CHECK_EQUAL(
    SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_FORMAT_THIRTY_TWO_BIT,
    message[0]);
}

TEST(CipEpath, GetLogicalValue8Bit) {
  CipOctet *message = (CipOctet *)calloc (6, sizeof(CipOctet) );
  CipOctet *original_address = message;
  message[0] = SEGMENT_TYPE_LOGICAL_SEGMENT | LOGICAL_SEGMENT_FORMAT_EIGHT_BIT;
  message[1] = 20;
  message[2] = 21;
  message[3] = 22;
  message[4] = 23;
  message[5] = 24;
  CipDword result = CipEpathGetLogicalValue( (const CipOctet **)&message );
  CHECK_EQUAL(20, result);
  free(original_address);
}

TEST(CipEpath, GetLogicalValue16Bit) {
  CipOctet *message = (CipOctet *)calloc (6, sizeof(CipOctet) );
  CipOctet *original_address = message;
  message[0] = SEGMENT_TYPE_LOGICAL_SEGMENT |
               LOGICAL_SEGMENT_FORMAT_SIXTEEN_BIT;
  message[1] = 0;
  message[2] = 21;
  message[3] = 22;
  message[4] = 23;
  message[5] = 24;
  CipDword result = CipEpathGetLogicalValue( (const CipOctet **)&message );
  CHECK_EQUAL(5653, result);
  free(original_address);
}

TEST(CipEpath, GetLogicalValue32Bit) {
  CipOctet *message = (CipOctet *)calloc (6, sizeof(CipOctet) );
  CipOctet *original_address = message;
  message[0] = SEGMENT_TYPE_LOGICAL_SEGMENT |
               LOGICAL_SEGMENT_FORMAT_THIRTY_TWO_BIT;
  message[1] = 0;
  message[2] = 21;
  message[3] = 22;
  message[4] = 23;
  message[5] = 24;
  CipDword result = CipEpathGetLogicalValue( (const CipOctet **)&message );
  CHECK_EQUAL(404166165, result);
  free(original_address);
}

TEST(CipEpath, SetLogicalValue8Bit) {
  const CipUsint value = 54;
  CipMessageRouterResponse response = {0};
  response.message.current_message_position = response.message.message_buffer;
  CipEpathSetLogicalValue(value, kLogicalSegmentLogicalFormatEightBit,
                          &response);
  CHECK_EQUAL(value, *response.message.message_buffer);
}

TEST(CipEpath, SetLogicalValue16Bit) {
  const CipUsint value = 54;
  CipMessageRouterResponse response = {0};
  response.message.current_message_position = response.message.message_buffer;
  CipEpathSetLogicalValue(value,
                          kLogicalSegmentLogicalFormatSixteenBit,
                          &response);
  CHECK_EQUAL(value, *(response.message.message_buffer + 1) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 2) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 3) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 4) );
}

TEST(CipEpath, SetLogicalValue32Bit) {
  const CipUsint value = 54;
  CipMessageRouterResponse response = {0};
  response.message.current_message_position = response.message.message_buffer;
  CipEpathSetLogicalValue(value,
                          kLogicalSegmentLogicalFormatThirtyTwoBit,
                          &response);
  CHECK_EQUAL(value, *(response.message.message_buffer + 1) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 2) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 3) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 4) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 5) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 6) );
  CHECK_EQUAL(0, *(response.message.message_buffer + 7) );
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeReserved) {
  const unsigned char message[] = {0x3C, 0x00};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeReserved, extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeArrayIndex) {
  const unsigned char message[] = {0x3C, 0x01};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeArrayIndex, extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeIndirectArrayIndex) {
  const unsigned char message[] = {0x3C, 0x02};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeIndirectArrayIndex,
              extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeBitIndex) {
  const unsigned char message[] = {0x3C, 0x03};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeBitIndex, extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeIndirectBitIndex) {
  const unsigned char message[] = {0x3C, 0x04};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeIndirectBitIndex,
              extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeStructureMemberNumber) {
  const unsigned char message[] = {0x3C, 0x05};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeStructureMemberNumber,
              extended_type);
}

TEST(CipEpath, GetLogicalSegmentExtendedLogicalTypeStructureMemberHandle) {
  const unsigned char message[] = {0x3C, 0x06};
  const LogicalSegmentExtendedLogicalType extended_type =
    GetPathLogicalSegmentExtendedLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentExtendedLogicalTypeStructureMemberHandle,
              extended_type);
}

TEST(CipEpath, GetLogicalSegmentSpecialTypeLogicalTypeReserved) {
  const unsigned char message[] = {0x35};
  LogicalSegmentSpecialTypeLogicalFormat special_type =
    GetPathLogicalSegmentSpecialTypeLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentSpecialTypeLogicalFormatReserved, special_type);
}

TEST(CipEpath, GetLogicalSegmentSpecialTypeLogicalTypeElectronicKey) {
  const unsigned char message[] = {0x34};
  LogicalSegmentSpecialTypeLogicalFormat special_type =
    GetPathLogicalSegmentSpecialTypeLogicalType(message);
  CHECK_EQUAL(kLogicalSegmentSpecialTypeLogicalFormatElectronicKey,
              special_type);
}

TEST(CipEpath, GetPathLogicalSegmentElectronicKeyFormatReserved) {
  const unsigned char message[] = {0x34, 0x00};
  ElectronicKeySegmentFormat key_format =
    GetPathLogicalSegmentElectronicKeyFormat(message);
  CHECK_EQUAL(kElectronicKeySegmentFormatReserved, key_format);
}

TEST(CipEpath, GetElectronicKeyFormat4FromMessage) {
  const unsigned char message[] = {0x34, 0x04};
  ElectronicKeySegmentFormat key_format =
    GetPathLogicalSegmentElectronicKeyFormat(message);
  CHECK_EQUAL(kElectronicKeySegmentFormatKeyFormat4, key_format);
}

TEST(CipEpath, GetLogicalSegmentElectronicKeyFormat4) {
  /* Size of an electronic key is 1 + 1 + 8 (Segment, Key format, Key) */
  const CipOctet message[] =
  { 0x34, 0x04, 0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x04, 0x05};
  const CipOctet *message_pp = (const CipOctet *)message;
  const CipOctet *message_buffer = message;
  ElectronicKeyFormat4 *electronic_key = ElectronicKeyFormat4New();
  GetElectronicKeyFormat4FromMessage(&message_pp, electronic_key);

  MEMCMP_EQUAL(message_buffer + 2, electronic_key, 8);

  ElectronicKeyFormat4Delete(&electronic_key);
}

TEST(CipEpath, GetPathNetworkSegmentSubtypeReserved) {
  const unsigned char message[] = {0x40};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeReserved, sub_type);
}

TEST(CipEpath, GetPathNetworkSegmentSubtypeScheduled) {
  const unsigned char message[] = {0x41};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeScheduleSegment, sub_type);
}

TEST(CipEpath, GetPathNetworkSegmentSubtypeFixedTag) {
  const unsigned char message[] = {0x42};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeFixedTagSegment, sub_type);
}

TEST(CipEpath,
     GetPathNetworkSegmentSubtypeProductionInhibitTimerInMilliseconds) {
  const unsigned char message[] = {0x43};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeProductionInhibitTimeInMilliseconds,
              sub_type);
}

TEST(CipEpath, GetPathNetworkSegmentSubtypeSafety) {
  const unsigned char message[] = {0x44};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeSafetySegment, sub_type);
}

TEST(CipEpath,
     GetPathNetworkSegmentSubtypeProductionInhibitTimerInMicroseconds) {
  const unsigned char message[] = {0x50};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeProductionInhibitTimeInMicroseconds,
              sub_type);
}

TEST(CipEpath, GetPathNetworkSegmentSubtypeExtendedNetwork) {
  const unsigned char message[] = {0x5F};
  NetworkSegmentSubtype sub_type = GetPathNetworkSegmentSubtype(message);
  CHECK_EQUAL(kNetworkSegmentSubtypeExtendedNetworkSegment, sub_type);
}

TEST(CipEpath, GetPathNetworkSegmentProductionInhibitTimeInMilliseconds) {
  const unsigned char message[] = {0x43, 0xFF};
  CipUsint time_im_milliseconds =
    GetPathNetworkSegmentProductionInhibitTimeInMilliseconds(message);
  CHECK_EQUAL(255, time_im_milliseconds);
}

TEST(CipEpath, GetPathNetworkSegmentProductionInhibitTimeInMicroseconds) {
  const unsigned char message[] = {0x50, 0x02, 0x00, 0x00, 0x00, 0xFF};
  CipUdint time_in_microseconds =
    GetPathNetworkSegmentProductionInhibitTimeInMicroseconds(message);
  CHECK_EQUAL(4278190080, time_in_microseconds);
}

TEST(CipEpath, GetPathDataSegmentSubtypeReserverd) {
  const unsigned char message[] = {0x81};
  DataSegmentSubtype type = GetPathDataSegmentSubtype(message);
  CHECK_EQUAL(kDataSegmentSubtypeReserved, type);
}

TEST(CipEpath, GetPathDataSegmentSubtypeSimpleData) {
  const unsigned char message[] = {0x80};
  DataSegmentSubtype type = GetPathDataSegmentSubtype(message);
  CHECK_EQUAL(kDataSegmentSubtypeSimpleData, type);
}

TEST(CipEpath, GetPathDataSegmentSubtypeANSIExtendedSymbol) {
  const unsigned char message[] = {0x91};
  DataSegmentSubtype type = GetPathDataSegmentSubtype(message);
  CHECK_EQUAL(kDataSegmentSubtypeANSIExtendedSymbol, type);
}

TEST(CipEpath, GetPathDataSegmentSimpleDataWordLength) {
  const unsigned char message[] = {0x80, 0x25};
  CipUsint length = GetPathDataSegmentSimpleDataWordLength(message);
  CHECK_EQUAL(37, length);
}

TEST(CipEpath, GetPathSymbolicSegmentFormatASCII) {
  const unsigned char message[] = {0x61};
  SymbolicSegmentFormat format = GetPathSymbolicSegmentFormat(message);
  CHECK_EQUAL(kSymbolicSegmentFormatASCII, format);
}

TEST(CipEpath, GetPathSymbolicSegmentFormatExtendedFormat) {
  const unsigned char message[] = {0x60};
  SymbolicSegmentFormat format = GetPathSymbolicSegmentFormat(message);
  CHECK_EQUAL(kSymbolicSegmentFormatExtendedString, format);
}

TEST(CipEpath, GetPathSymbolicSegmentASCIIFormatLength) {
  const unsigned char message[] = {0x61};
  SymbolicSegmentFormat format = GetPathSymbolicSegmentFormat(message);
  CHECK_EQUAL(kSymbolicSegmentFormatASCII, format);
}

TEST(CipEpath, GetPathSymbolicSegmentNumericTypeReserved) {
  const unsigned char message[] = {0x60, 0xC0};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentNumericType(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatReserved, format);
}

TEST(CipEpath, GetPathSymbolicSegmentNumericTypeUSINT) {
  const unsigned char message[] = {0x60, 0xC6};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentNumericType(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUSINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentNumericTypeUINT) {
  const unsigned char message[] = {0x60, 0xC7};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentNumericType(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentNumericTypeUDINT) {
  const unsigned char message[] = {0x60, 0xC8};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentNumericType(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUDINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatReserverd) {
  const unsigned char message[] = {0x60, 0x00};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatReserved, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatDoubleChars) {
  const unsigned char message[] = {0x60, 0x20};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatDoubleByteChars, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatTripleChars) {
  const unsigned char message[] = {0x60, 0x40};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatTripleByteChars, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatUSINT) {
  const unsigned char message[] = {0x60, 0xC6};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUSINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatUINT) {
  const unsigned char message[] = {0x60, 0xC7};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatUDINT) {
  const unsigned char message[] = {0x60, 0xC8};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatNumericSymbolUDINT, format);
}

TEST(CipEpath, GetPathSymbolicSegmentExtendedFormatNumericReserved) {
  const unsigned char message[] = {0x60, 0xC9};
  SymbolicSegmentExtendedFormat format = GetPathSymbolicSegmentExtendedFormat(
    message);
  CHECK_EQUAL(kSymbolicSegmentExtendedFormatReserved, format);
}