test_wire.cpp

Go to the documentation of this file.

 
 
#include <gtest/gtest.h>
 
#include <array>
#include <cstdint>
#include <string>
#include <vector>
 
#include "profinet/wire.h"
 
namespace profinet::wire
{
 
TEST(WireWriterTest, PutBigEndianU8)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint8_t>(data, 0x42U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0x42U}));
}
 
TEST(WireWriterTest, PutBigEndianU16)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint16_t>(data, 0x1234U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0x12U, 0x34U}));
}
 
TEST(WireWriterTest, PutBigEndianU32)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint32_t>(data, 0x12345678U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x12U,
          0x34U,
          0x56U,
          0x78U,
      }));
}
 
TEST(WireWriterTest, PutBigEndianU64)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint64_t>(data, 0x0123456789ABCDEFULL);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x01U,
          0x23U,
          0x45U,
          0x67U,
          0x89U,
          0xABU,
          0xCDU,
          0xEFU,
      }));
}
 
TEST(WireWriterTest, PutBigEndianZero)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint32_t>(data, 0U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x00U,
          0x00U,
          0x00U,
          0x00U,
      }));
}
 
TEST(WireWriterTest, PutBigEndianMaximumU32)
{
  std::vector<std::uint8_t> data;
 
  PutBigEndian<std::uint32_t>(data, UINT32_MAX);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xFFU,
          0xFFU,
          0xFFU,
          0xFFU,
      }));
}
 
TEST(WireWriterTest, PutBigEndianAppends)
{
  std::vector<std::uint8_t> data = {
      0xAAU,
      0xBBU,
  };
 
  PutBigEndian<std::uint16_t>(data, 0x1234U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xAAU,
          0xBBU,
          0x12U,
          0x34U,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianU8)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint8_t>(data, 0x42U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0x42U}));
}
 
TEST(WireWriterTest, PutLittleEndianU16)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint16_t>(data, 0x1234U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0x34U, 0x12U}));
}
 
TEST(WireWriterTest, PutLittleEndianU32)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint32_t>(data, 0x12345678U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x78U,
          0x56U,
          0x34U,
          0x12U,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianU64)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint64_t>(data, 0x0123456789ABCDEFULL);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xEFU,
          0xCDU,
          0xABU,
          0x89U,
          0x67U,
          0x45U,
          0x23U,
          0x01U,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianZero)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint32_t>(data, 0U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x00U,
          0x00U,
          0x00U,
          0x00U,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianMaximumU32)
{
  std::vector<std::uint8_t> data;
 
  PutLittleEndian<std::uint32_t>(data, UINT32_MAX);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xFFU,
          0xFFU,
          0xFFU,
          0xFFU,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianAppends)
{
  std::vector<std::uint8_t> data = {
      0xAAU,
      0xBBU,
  };
 
  PutLittleEndian<std::uint16_t>(data, 0x1234U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xAAU,
          0xBBU,
          0x34U,
          0x12U,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianPointerU16)
{
  std::array<std::uint8_t, 4U> data = {
      0xAAU,
      0xBBU,
      0xCCU,
      0xDDU,
  };
 
  PutLittleEndian<std::uint16_t>(data.data() + 1U, 0x1234U);
 
  EXPECT_EQ(
      data,
      (std::array<std::uint8_t, 4U>{
          0xAAU,
          0x34U,
          0x12U,
          0xDDU,
      }));
}
 
TEST(WireWriterTest, PutLittleEndianPointerU32)
{
  std::array<std::uint8_t, 6U> data = {
      0xAAU,
      0xBBU,
      0xCCU,
      0xDDU,
      0xEEU,
      0xFFU,
  };
 
  PutLittleEndian<std::uint32_t>(data.data() + 1U, 0x12345678U);
 
  EXPECT_EQ(
      data,
      (std::array<std::uint8_t, 6U>{
          0xAAU,
          0x78U,
          0x56U,
          0x34U,
          0x12U,
          0xFFU,
      }));
}
 
TEST(WireWriterTest, PutU8)
{
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutU8(data, 0x42U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0xAAU, 0x42U}));
}
 
TEST(WireWriterTest, PutU16)
{
  std::vector<std::uint8_t> data;
 
  PutU16(data, 0x1234U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0x12U, 0x34U}));
}
 
TEST(WireWriterTest, PutU32)
{
  std::vector<std::uint8_t> data;
 
  PutU32(data, 0x12345678U);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x12U,
          0x34U,
          0x56U,
          0x78U,
      }));
}
 
TEST(WireWriterTest, PutBytes)
{
  const std::array<std::uint8_t, 3U> source = {
      0x10U,
      0x20U,
      0x30U,
  };
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutBytes(data, source.data(), source.size());
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xAAU,
          0x10U,
          0x20U,
          0x30U,
      }));
}
 
TEST(WireWriterTest, PutBytesZeroLength)
{
  const std::array<std::uint8_t, 1U> source = {0x42U};
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutBytes(data, source.data(), 0U);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0xAAU}));
}
 
TEST(WireWriterTest, PutFixedArray)
{
  const std::array<std::uint8_t, 3U> source = {
      0x10U,
      0x20U,
      0x30U,
  };
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutFixed(data, source);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xAAU,
          0x10U,
          0x20U,
          0x30U,
      }));
}
 
TEST(WireWriterTest, PutFixedEmptyArray)
{
  const std::array<std::uint8_t, 0U> source{};
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutFixed(data, source);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0xAAU}));
}
 
TEST(WireWriterTest, PutFixedVector)
{
  const std::vector<std::uint8_t> source = {
      0x10U,
      0x20U,
      0x30U,
  };
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutFixed(data, source);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0xAAU,
          0x10U,
          0x20U,
          0x30U,
      }));
}
 
TEST(WireWriterTest, PutFixedEmptyVector)
{
  const std::vector<std::uint8_t> source;
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutFixed(data, source);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0xAAU}));
}
 
TEST(WireWriterTest, PutFixedString)
{
  const std::string source = "ABC";
  std::vector<std::uint8_t> data;
 
  PutFixed(data, source);
 
  EXPECT_EQ(
      data,
      (std::vector<std::uint8_t>{
          0x41U,
          0x42U,
          0x43U,
      }));
}
 
TEST(WireWriterTest, PutFixedEmptyString)
{
  const std::string source;
  std::vector<std::uint8_t> data = {0xAAU};
 
  PutFixed(data, source);
 
  EXPECT_EQ(data, (std::vector<std::uint8_t>{0xAAU}));
}
 
TEST(WireReaderTest, ReadBigEndianU8)
{
  const std::array<std::uint8_t, 1U> data = {0x42U};
 
  EXPECT_EQ(ReadBigEndian<std::uint8_t>(data.data()), 0x42U);
}
 
TEST(WireReaderTest, ReadBigEndianU16)
{
  const std::array<std::uint8_t, 2U> data = {
      0x12U,
      0x34U,
  };
 
  EXPECT_EQ(ReadBigEndian<std::uint16_t>(data.data()), 0x1234U);
}
 
TEST(WireReaderTest, ReadBigEndianU32)
{
  const std::array<std::uint8_t, 4U> data = {
      0x12U,
      0x34U,
      0x56U,
      0x78U,
  };
 
  EXPECT_EQ(ReadBigEndian<std::uint32_t>(data.data()), 0x12345678U);
}
 
TEST(WireReaderTest, ReadBigEndianU64)
{
  const std::array<std::uint8_t, 8U> data = {
      0x01U,
      0x23U,
      0x45U,
      0x67U,
      0x89U,
      0xABU,
      0xCDU,
      0xEFU,
  };
 
  EXPECT_EQ(
      ReadBigEndian<std::uint64_t>(data.data()),
      0x0123456789ABCDEFULL);
}
 
TEST(WireReaderTest, ReadBigEndianZero)
{
  const std::array<std::uint8_t, 4U> data = {
      0x00U,
      0x00U,
      0x00U,
      0x00U,
  };
 
  EXPECT_EQ(ReadBigEndian<std::uint32_t>(data.data()), 0U);
}
 
TEST(WireReaderTest, ReadBigEndianMaximumU32)
{
  const std::array<std::uint8_t, 4U> data = {
      0xFFU,
      0xFFU,
      0xFFU,
      0xFFU,
  };
 
  EXPECT_EQ(ReadBigEndian<std::uint32_t>(data.data()), UINT32_MAX);
}
 
TEST(WireReaderTest, ReadLittleEndianU8)
{
  const std::array<std::uint8_t, 1U> data = {0x42U};
 
  EXPECT_EQ(ReadLittleEndian<std::uint8_t>(data.data()), 0x42U);
}
 
TEST(WireReaderTest, ReadLittleEndianU16)
{
  const std::array<std::uint8_t, 2U> data = {
      0x34U,
      0x12U,
  };
 
  EXPECT_EQ(ReadLittleEndian<std::uint16_t>(data.data()), 0x1234U);
}
 
TEST(WireReaderTest, ReadLittleEndianU32)
{
  const std::array<std::uint8_t, 4U> data = {
      0x78U,
      0x56U,
      0x34U,
      0x12U,
  };
 
  EXPECT_EQ(ReadLittleEndian<std::uint32_t>(data.data()), 0x12345678U);
}
 
TEST(WireReaderTest, ReadLittleEndianU64)
{
  const std::array<std::uint8_t, 8U> data = {
      0xEFU,
      0xCDU,
      0xABU,
      0x89U,
      0x67U,
      0x45U,
      0x23U,
      0x01U,
  };
 
  EXPECT_EQ(
      ReadLittleEndian<std::uint64_t>(data.data()),
      0x0123456789ABCDEFULL);
}
 
TEST(WireReaderTest, ReadLittleEndianZero)
{
  const std::array<std::uint8_t, 4U> data = {
      0x00U,
      0x00U,
      0x00U,
      0x00U,
  };
 
  EXPECT_EQ(ReadLittleEndian<std::uint32_t>(data.data()), 0U);
}
 
TEST(WireReaderTest, ReadLittleEndianMaximumU32)
{
  const std::array<std::uint8_t, 4U> data = {
      0xFFU,
      0xFFU,
      0xFFU,
      0xFFU,
  };
 
  EXPECT_EQ(ReadLittleEndian<std::uint32_t>(data.data()), UINT32_MAX);
}
 
TEST(WireReaderTest, ReaderReadsU8)
{
  const std::vector<std::uint8_t> data = {0x42U};
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U8(), 0x42U);
  EXPECT_EQ(reader.Position(), 1U);
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderRejectsU8PastEnd)
{
  const std::vector<std::uint8_t> data;
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.U8(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderReadsBigEndianU16)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.Position(), 2U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderReadsBigEndianU32)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x56U,
      0x78U,
      0x90U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U32(), 0x12345678U);
  EXPECT_EQ(reader.Position(), 4U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderReadsLittleEndianU16)
{
  const std::vector<std::uint8_t> data = {
      0x34U,
      0x12U,
      0x56U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U16LittleEndian(), 0x1234U);
  EXPECT_EQ(reader.Position(), 2U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderReadsLittleEndianU32)
{
  const std::vector<std::uint8_t> data = {
      0x78U,
      0x56U,
      0x34U,
      0x12U,
      0x90U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U32LittleEndian(), 0x12345678U);
  EXPECT_EQ(reader.Position(), 4U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderReadsConsecutiveLittleEndianValues)
{
  const std::vector<std::uint8_t> data = {
      0x34U,
      0x12U,
      0x78U,
      0x56U,
      0x34U,
      0x12U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U16LittleEndian(), 0x1234U);
  EXPECT_EQ(reader.U32LittleEndian(), 0x12345678U);
  EXPECT_EQ(reader.Position(), 6U);
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderMixesEndianReads)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x78U,
      0x56U,
      0xABU,
      0xCDU,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.U16LittleEndian(), 0x5678U);
  EXPECT_EQ(reader.U16(), 0xABCDU);
  EXPECT_EQ(reader.Position(), 6U);
}
 
TEST(WireReaderTest, ReaderRejectsLittleEndianU16PastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.U16LittleEndian(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderRejectsLittleEndianU32PastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.U32LittleEndian(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 3U);
}
 
TEST(WireReaderTest, ReaderRejectsU16PastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.U16(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderRejectsU32PastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.U32(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 3U);
}
 
TEST(WireReaderTest, ReaderReadBytes)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
      0x40U,
  };
 
  Reader reader(data);
 
  const std::vector<std::uint8_t> result = reader.ReadBytes(2U);
 
  EXPECT_EQ(result, (std::vector<std::uint8_t>{0x10U, 0x20U}));
  EXPECT_EQ(reader.Position(), 2U);
  EXPECT_EQ(reader.Remaining(), 2U);
}
 
TEST(WireReaderTest, ReaderReadBytesZeroLength)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
  };
 
  Reader reader(data);
 
  const std::vector<std::uint8_t> result = reader.ReadBytes(0U);
 
  EXPECT_TRUE(result.empty());
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 2U);
}
 
TEST(WireReaderTest, ReaderRejectsReadBytesPastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.ReadBytes(4U), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 3U);
}
 
TEST(WireReaderTest, ReaderFixedArray)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
      0x40U,
  };
 
  Reader reader(data);
 
  const std::array<std::uint8_t, 3U> result = reader.Fixed<3U>();
 
  EXPECT_EQ(
      result,
      (std::array<std::uint8_t, 3U>{
          0x10U,
          0x20U,
          0x30U,
      }));
  EXPECT_EQ(reader.Position(), 3U);
  EXPECT_EQ(reader.Remaining(), 1U);
}
 
TEST(WireReaderTest, ReaderFixedEmptyArray)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
  };
 
  Reader reader(data);
 
  const auto result = reader.Fixed<0U>();
 
  EXPECT_EQ(result, (std::array<std::uint8_t, 0U>{}));
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 2U);
}
 
TEST(WireReaderTest, ReaderRejectsFixedArrayPastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW((void)reader.Fixed<3U>(), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 2U);
}
 
TEST(WireReaderTest, ReaderSkip)
{
  const std::vector<std::uint8_t> data = {
      0xAAU,
      0xBBU,
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data);
 
  reader.Skip(2U);
 
  EXPECT_EQ(reader.Position(), 2U);
  EXPECT_EQ(reader.Remaining(), 3U);
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.Position(), 4U);
  EXPECT_EQ(reader.Remaining(), 1U);
  EXPECT_EQ(reader.U8(), 0x56U);
  EXPECT_EQ(reader.Position(), 5U);
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderSkipZero)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
  };
 
  Reader reader(data);
 
  reader.Skip(0U);
 
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 2U);
}
 
TEST(WireReaderTest, ReaderRejectsSkipPastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW(reader.Skip(4U), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 3U);
}
 
TEST(WireReaderTest, ReaderSkipTo)
{
  const std::vector<std::uint8_t> data = {
      0xAAU,
      0xBBU,
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data);
 
  reader.SkipTo(2U);
 
  EXPECT_EQ(reader.Position(), 2U);
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.Position(), 4U);
}
 
TEST(WireReaderTest, ReaderSkipToMovesBackwards)
{
  const std::vector<std::uint8_t> data = {
      0x12U,
      0x34U,
      0x56U,
      0x78U,
  };
 
  Reader reader(data);
 
  reader.Skip(4U);
  reader.SkipTo(1U);
 
  EXPECT_EQ(reader.Position(), 1U);
  EXPECT_EQ(reader.U16(), 0x3456U);
}
 
TEST(WireReaderTest, ReaderRejectsSkipToPastEnd)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
  };
 
  Reader reader(data);
 
  EXPECT_THROW(reader.SkipTo(4U), std::out_of_range);
  EXPECT_EQ(reader.Position(), 0U);
}
 
TEST(WireReaderTest, ReaderAllowsSkipToEnd)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
  };
 
  Reader reader(data);
 
  reader.SkipTo(data.size());
 
  EXPECT_EQ(reader.Position(), data.size());
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderNeedExactRemaining)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
  };
 
  Reader reader(data);
 
  EXPECT_NO_THROW(reader.Need(2U));
  EXPECT_EQ(reader.Position(), 0U);
}
 
TEST(WireReaderTest, ReaderNeedZero)
{
  const std::vector<std::uint8_t> data;
 
  Reader reader(data);
 
  EXPECT_NO_THROW(reader.Need(0U));
}
 
TEST(WireReaderTest, ReaderCursorPointsToCurrentPosition)
{
  const std::vector<std::uint8_t> data = {
      0xAAU,
      0xBBU,
      0xCCU,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(*reader.Cursor(), 0xAAU);
 
  reader.SkipTo(2U);
 
  EXPECT_EQ(*reader.Cursor(), 0xCCU);
}
 
TEST(WireReaderTest, ReaderRemainingTracksPosition)
{
  const std::vector<std::uint8_t> data = {
      0x10U,
      0x20U,
      0x30U,
      0x40U,
      0x50U,
  };
 
  Reader reader(data);
 
  EXPECT_EQ(reader.Remaining(), 5U);
 
  reader.Skip(2U);
  EXPECT_EQ(reader.Remaining(), 3U);
 
  reader.U8();
  EXPECT_EQ(reader.Remaining(), 2U);
 
  reader.SkipTo(4U);
  EXPECT_EQ(reader.Remaining(), 1U);
 
  reader.U8();
  EXPECT_EQ(reader.Remaining(), 0U);
}
 
TEST(WireReaderTest, ReaderRawPointerConstructor)
{
  const std::array<std::uint8_t, 3U> data = {
      0x12U,
      0x34U,
      0x56U,
  };
 
  Reader reader(data.data(), data.size());
 
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.U8(), 0x56U);
  EXPECT_EQ(reader.Position(), 3U);
}
 
TEST(WireReaderTest, ReaderSpanConstructor)
{
  const std::array<std::uint8_t, 2U> data = {
      0x12U,
      0x34U,
  };
 
  const std::span<const std::uint8_t> bytes(data);
 
  Reader reader(bytes);
 
  EXPECT_EQ(reader.U16(), 0x1234U);
  EXPECT_EQ(reader.Position(), 2U);
}
 
TEST(WireReaderTest, ReaderEmptyVector)
{
  const std::vector<std::uint8_t> data;
 
  Reader reader(data);
 
  EXPECT_EQ(reader.Position(), 0U);
  EXPECT_EQ(reader.Remaining(), 0U);
  EXPECT_THROW((void)reader.U8(), std::out_of_range);
}
 
} // namespace profinet::wire