test/message/payload.cpp - openbmc/phosphor-host-ipmid - Gitiles

 /**
  * Copyright © 2018 Intel Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #define SD_JOURNAL_SUPPRESS_LOCATION

 #include <systemd/sd-journal.h>

 #include <ipmid/api.hpp>
 #include <ipmid/message.hpp>
 #include <stdexcept>

 #include <gtest/gtest.h>

 TEST(Payload, InputSize)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     size_t input_size = i.size();
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     ASSERT_EQ(input_size, p.size());
 }

 TEST(Payload, OutputSize)
 {
     ipmi::message::Payload p;
     ASSERT_EQ(0, p.size());
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     p.pack(i);
     ASSERT_EQ(i.size(), p.size());
     p.pack(i);
     p.pack(i);
     ASSERT_EQ(3 * i.size(), p.size());
 }

 TEST(Payload, Resize)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p;
     p.pack(i);
     p.resize(16);
     ASSERT_EQ(p.size(), 16);
 }

 TEST(Payload, Data)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p;
     p.pack(i);
     ASSERT_NE(nullptr, p.data());
 }

 TEST(PayloadResponse, Append)
 {
     std::string s("0123456789abcdef");
     ipmi::message::Payload p;
     p.append(s.data(), s.data() + s.size());
     ASSERT_EQ(s.size(), p.size());
 }

 TEST(PayloadResponse, AppendDrain)
 {
     std::string s("0123456789abcdef");
     ipmi::message::Payload p;
     bool b = true;
     // first pack a lone bit
     p.pack(b);
     p.append(s.data(), s.data() + s.size());
     // append will 'drain' first, padding the lone bit into a full byte
     ASSERT_EQ(s.size() + 1, p.size());
 }

 TEST(PayloadResponse, AppendBits)
 {
     ipmi::message::Payload p;
     p.appendBits(3, 0b101);
     ASSERT_EQ(p.bitStream, 0b101);
     p.appendBits(4, 0b1100);
     ASSERT_EQ(p.bitStream, 0b1100101);
     p.appendBits(1, 0b1);
     ASSERT_EQ(p.bitStream, 0);
     ASSERT_EQ(p.bitCount, 0);
     // appended 8 bits, should be one byte
     ASSERT_EQ(p.size(), 1);
     std::vector<uint8_t> k1 = {0b11100101};
     ASSERT_EQ(p.raw, k1);
     p.appendBits(7, 0b1110111);
     // appended 7 more bits, should still be one byte
     ASSERT_EQ(p.size(), 1);
     p.drain();
     // drain forces padding; should be two bytes now
     ASSERT_EQ(p.size(), 2);
     std::vector<uint8_t> k2 = {0b11100101, 0b01110111};
     ASSERT_EQ(p.raw, k2);
 }

 TEST(PayloadResponse, Drain16Bits)
 {
     ipmi::message::Payload p;
     p.bitStream = 0b1011010011001111;
     p.bitCount = 16;
     p.drain();
     ASSERT_EQ(p.size(), 2);
     ASSERT_EQ(p.bitCount, 0);
     ASSERT_EQ(p.bitStream, 0);
     std::vector<uint8_t> k1 = {0b11001111, 0b10110100};
     ASSERT_EQ(p.raw, k1);
 }

 TEST(PayloadResponse, Drain15Bits)
 {
     ipmi::message::Payload p;
     p.bitStream = 0b101101001100111;
     p.bitCount = 15;
     p.drain();
     ASSERT_EQ(p.size(), 2);
     ASSERT_EQ(p.bitCount, 0);
     ASSERT_EQ(p.bitStream, 0);
     std::vector<uint8_t> k1 = {0b1100111, 0b1011010};
     ASSERT_EQ(p.raw, k1);
 }

 TEST(PayloadResponse, Drain15BitsWholeBytesOnly)
 {
     ipmi::message::Payload p;
     p.bitStream = 0b101101001100111;
     p.bitCount = 15;
     p.drain(true);
     // only the first whole byte should have been 'drained' into p.raw
     ASSERT_EQ(p.size(), 1);
     ASSERT_EQ(p.bitCount, 7);
     ASSERT_EQ(p.bitStream, 0b1011010);
     std::vector<uint8_t> k1 = {0b1100111};
     ASSERT_EQ(p.raw, k1);
 }

 TEST(PayloadRequest, Pop)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     const auto& [vb, ve] = p.pop<uint8_t>(4);
     std::vector<uint8_t> v(vb, ve);
     std::vector<uint8_t> k = {0xbf, 0x04, 0x86, 0x00};
     ASSERT_EQ(v, k);
 }

 TEST(PayloadRequest, FillBits)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(5);
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0xbf);
     ASSERT_EQ(p.bitCount, 8);
     // should still have 5 bits available, no change
     p.fillBits(5);
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0xbf);
     ASSERT_EQ(p.bitCount, 8);
     // discard 5 bits (low order)
     p.popBits(5);
     // should add another byte into the stream (high order)
     p.fillBits(5);
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0x25);
     ASSERT_EQ(p.bitCount, 11);
 }

 TEST(PayloadRequest, FillBitsTooManyBits)
 {
     std::vector<uint8_t> i = {1, 2, 3, 4, 5, 6, 7, 8, 9};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(72);
     ASSERT_TRUE(p.unpackError);
 }

 TEST(PayloadRequest, FillBitsNotEnoughBytes)
 {
     std::vector<uint8_t> i = {1, 2, 3, 4};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(48);
     ASSERT_TRUE(p.unpackError);
 }

 TEST(PayloadRequest, PopBits)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(4);
     uint8_t v = p.popBits(4);
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0x0b);
     ASSERT_EQ(p.bitCount, 4);
     ASSERT_EQ(v, 0x0f);
 }

 TEST(PayloadRequest, PopBitsNoFillBits)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.popBits(4);
     ASSERT_TRUE(p.unpackError);
 }

 TEST(PayloadRequest, DiscardBits)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(5);
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0xbf);
     ASSERT_EQ(p.bitCount, 8);
     p.discardBits();
     ASSERT_FALSE(p.unpackError);
     ASSERT_EQ(p.bitStream, 0);
     ASSERT_EQ(p.bitCount, 0);
 }

 TEST(PayloadRequest, FullyUnpacked)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     uint32_t v1;
     p.unpack(v1);
     // still one remaining byte
     ASSERT_FALSE(p.fullyUnpacked());
     p.fillBits(3);
     p.popBits(3);
     // still five remaining bits
     ASSERT_FALSE(p.fullyUnpacked());
     p.fillBits(5);
     p.popBits(5);
     // fully unpacked, should be no errors
     ASSERT_TRUE(p.fullyUnpacked());
     p.fillBits(4);
     // fullyUnpacked fails because an attempt to unpack too many bytes
     ASSERT_FALSE(p.fullyUnpacked());
 }

 TEST(PayloadRequest, ResetInternal)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     p.fillBits(4);
     p.unpackError = true;
     p.reset();
     ASSERT_EQ(p.rawIndex, 0);
     ASSERT_EQ(p.bitStream, 0);
     ASSERT_EQ(p.bitCount, 0);
     ASSERT_FALSE(p.unpackError);
 }

 TEST(PayloadRequest, ResetUsage)
 {
     // Payload.reset is used to rewind the unpacking to the initial
     // state. This is needed so that OEM commands can unpack the group
     // number or the IANA to determine which handler needs to be called
     std::vector<uint8_t> i = {0x04, 0x86};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     uint8_t v1;
     // check that the number of bytes matches
     ASSERT_EQ(p.unpack(v1), 0);
     // check that the payload was not fully unpacked
     ASSERT_FALSE(p.fullyUnpacked());
     uint8_t k1 = 0x04;
     // check that the bytes were correctly unpacked (LSB first)
     ASSERT_EQ(v1, k1);
     // do a reset on the payload
     p.reset();
     // unpack a uint16
     uint16_t v2;
     // check that the number of bytes matches
     ASSERT_EQ(p.unpack(v2), 0);
     // check that the payload was fully unpacked
     ASSERT_TRUE(p.fullyUnpacked());
     uint16_t k2 = 0x8604;
     // check that the bytes were correctly unpacked (LSB first)
     ASSERT_EQ(v2, k2);
 }

 TEST(PayloadRequest, PartialPayload)
 {
     std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
     ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
     uint8_t v1;
     ipmi::message::Payload localPayload;
     // check that the number of bytes matches
     ASSERT_EQ(p.unpack(v1, localPayload), 0);
     // check that the payload was partially unpacked and not in error
     ASSERT_FALSE(p.fullyUnpacked());
     ASSERT_FALSE(p.unpackError);
     // check that the 'extracted' payload is not fully unpacked
     ASSERT_FALSE(localPayload.fullyUnpacked());
     uint8_t k1 = 0xbf;
     // check that the bytes were correctly unpacked (LSB first)
     ASSERT_EQ(v1, k1);
     uint32_t v2;
     // unpack using the 'extracted' payload
     ASSERT_EQ(localPayload.unpack(v2), 0);
     ASSERT_TRUE(localPayload.fullyUnpacked());
     uint32_t k2 = 0x02008604;
     ASSERT_EQ(v2, k2);
 }

 std::vector<std::string> logs;

 extern "C" {
 int sd_journal_send(const char* format, ...)
 {
     logs.push_back(format);
     return 0;
 }

 int sd_journal_send_with_location(const char* file, const char* line,
                                   const char* func, const char* format, ...)
 {
     logs.push_back(format);
     return 0;
 }
 }

 class PayloadLogging : public testing::Test
 {
   public:
     void SetUp()
     {
         logs.clear();
     }
 };

 TEST_F(PayloadLogging, TrailingOk)
 {
     {
         ipmi::message::Payload p({1, 2});
     }
     EXPECT_EQ(logs.size(), 0);
 }

 TEST_F(PayloadLogging, EnforcingUnchecked)
 {
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
     }
     EXPECT_EQ(logs.size(), 1);
 }

 TEST_F(PayloadLogging, EnforcingUncheckedUnpacked)
 {
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
         uint8_t out;
         p.unpack(out, out);
     }
     EXPECT_EQ(logs.size(), 1);
 }

 TEST_F(PayloadLogging, EnforcingUncheckedError)
 {
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
         uint32_t out;
         p.unpack(out);
     }
     EXPECT_EQ(logs.size(), 0);
 }

 TEST_F(PayloadLogging, EnforcingChecked)
 {
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
         EXPECT_FALSE(p.fullyUnpacked());
     }
     EXPECT_EQ(logs.size(), 0);
 }

 TEST_F(PayloadLogging, EnforcingCheckedUnpacked)
 {
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
         uint8_t out;
         p.unpack(out, out);
         EXPECT_TRUE(p.fullyUnpacked());
     }
     EXPECT_EQ(logs.size(), 0);
 }

 TEST_F(PayloadLogging, EnforcingUnpackPayload)
 {
     {
         ipmi::message::Payload p;
         {
             ipmi::message::Payload q({1, 2});
             q.trailingOk = false;
             q.unpack(p);
         }
         EXPECT_EQ(logs.size(), 0);
     }
     EXPECT_EQ(logs.size(), 1);
 }

 TEST_F(PayloadLogging, EnforcingMove)
 {
     {
         ipmi::message::Payload p;
         {
             ipmi::message::Payload q({1, 2});
             q.trailingOk = false;
             p = std::move(q);
         }
         EXPECT_EQ(logs.size(), 0);
     }
     EXPECT_EQ(logs.size(), 1);
 }

 TEST_F(PayloadLogging, EnforcingException)
 {
     try
     {
         ipmi::message::Payload p({1, 2});
         p.trailingOk = false;
         throw std::runtime_error("test");
     }
     catch (...)
     {
     }
     EXPECT_EQ(logs.size(), 0);
 }
	/**
	* Copyright © 2018 Intel Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#define SD_JOURNAL_SUPPRESS_LOCATION

	#include <systemd/sd-journal.h>

	#include <ipmid/api.hpp>
	#include <ipmid/message.hpp>
	#include <stdexcept>

	#include <gtest/gtest.h>

	TEST(Payload, InputSize)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	size_t input_size = i.size();
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	ASSERT_EQ(input_size, p.size());
	}

	TEST(Payload, OutputSize)
	{
	ipmi::message::Payload p;
	ASSERT_EQ(0, p.size());
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	p.pack(i);
	ASSERT_EQ(i.size(), p.size());
	p.pack(i);
	p.pack(i);
	ASSERT_EQ(3 * i.size(), p.size());
	}

	TEST(Payload, Resize)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p;
	p.pack(i);
	p.resize(16);
	ASSERT_EQ(p.size(), 16);
	}

	TEST(Payload, Data)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p;
	p.pack(i);
	ASSERT_NE(nullptr, p.data());
	}

	TEST(PayloadResponse, Append)
	{
	std::string s("0123456789abcdef");
	ipmi::message::Payload p;
	p.append(s.data(), s.data() + s.size());
	ASSERT_EQ(s.size(), p.size());
	}

	TEST(PayloadResponse, AppendDrain)
	{
	std::string s("0123456789abcdef");
	ipmi::message::Payload p;
	bool b = true;
	// first pack a lone bit
	p.pack(b);
	p.append(s.data(), s.data() + s.size());
	// append will 'drain' first, padding the lone bit into a full byte
	ASSERT_EQ(s.size() + 1, p.size());
	}

	TEST(PayloadResponse, AppendBits)
	{
	ipmi::message::Payload p;
	p.appendBits(3, 0b101);
	ASSERT_EQ(p.bitStream, 0b101);
	p.appendBits(4, 0b1100);
	ASSERT_EQ(p.bitStream, 0b1100101);
	p.appendBits(1, 0b1);
	ASSERT_EQ(p.bitStream, 0);
	ASSERT_EQ(p.bitCount, 0);
	// appended 8 bits, should be one byte
	ASSERT_EQ(p.size(), 1);
	std::vector<uint8_t> k1 = {0b11100101};
	ASSERT_EQ(p.raw, k1);
	p.appendBits(7, 0b1110111);
	// appended 7 more bits, should still be one byte
	ASSERT_EQ(p.size(), 1);
	p.drain();
	// drain forces padding; should be two bytes now
	ASSERT_EQ(p.size(), 2);
	std::vector<uint8_t> k2 = {0b11100101, 0b01110111};
	ASSERT_EQ(p.raw, k2);
	}

	TEST(PayloadResponse, Drain16Bits)
	{
	ipmi::message::Payload p;
	p.bitStream = 0b1011010011001111;
	p.bitCount = 16;
	p.drain();
	ASSERT_EQ(p.size(), 2);
	ASSERT_EQ(p.bitCount, 0);
	ASSERT_EQ(p.bitStream, 0);
	std::vector<uint8_t> k1 = {0b11001111, 0b10110100};
	ASSERT_EQ(p.raw, k1);
	}

	TEST(PayloadResponse, Drain15Bits)
	{
	ipmi::message::Payload p;
	p.bitStream = 0b101101001100111;
	p.bitCount = 15;
	p.drain();
	ASSERT_EQ(p.size(), 2);
	ASSERT_EQ(p.bitCount, 0);
	ASSERT_EQ(p.bitStream, 0);
	std::vector<uint8_t> k1 = {0b1100111, 0b1011010};
	ASSERT_EQ(p.raw, k1);
	}

	TEST(PayloadResponse, Drain15BitsWholeBytesOnly)
	{
	ipmi::message::Payload p;
	p.bitStream = 0b101101001100111;
	p.bitCount = 15;
	p.drain(true);
	// only the first whole byte should have been 'drained' into p.raw
	ASSERT_EQ(p.size(), 1);
	ASSERT_EQ(p.bitCount, 7);
	ASSERT_EQ(p.bitStream, 0b1011010);
	std::vector<uint8_t> k1 = {0b1100111};
	ASSERT_EQ(p.raw, k1);
	}

	TEST(PayloadRequest, Pop)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	const auto& [vb, ve] = p.pop<uint8_t>(4);
	std::vector<uint8_t> v(vb, ve);
	std::vector<uint8_t> k = {0xbf, 0x04, 0x86, 0x00};
	ASSERT_EQ(v, k);
	}

	TEST(PayloadRequest, FillBits)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(5);
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0xbf);
	ASSERT_EQ(p.bitCount, 8);
	// should still have 5 bits available, no change
	p.fillBits(5);
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0xbf);
	ASSERT_EQ(p.bitCount, 8);
	// discard 5 bits (low order)
	p.popBits(5);
	// should add another byte into the stream (high order)
	p.fillBits(5);
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0x25);
	ASSERT_EQ(p.bitCount, 11);
	}

	TEST(PayloadRequest, FillBitsTooManyBits)
	{
	std::vector<uint8_t> i = {1, 2, 3, 4, 5, 6, 7, 8, 9};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(72);
	ASSERT_TRUE(p.unpackError);
	}

	TEST(PayloadRequest, FillBitsNotEnoughBytes)
	{
	std::vector<uint8_t> i = {1, 2, 3, 4};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(48);
	ASSERT_TRUE(p.unpackError);
	}

	TEST(PayloadRequest, PopBits)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(4);
	uint8_t v = p.popBits(4);
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0x0b);
	ASSERT_EQ(p.bitCount, 4);
	ASSERT_EQ(v, 0x0f);
	}

	TEST(PayloadRequest, PopBitsNoFillBits)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.popBits(4);
	ASSERT_TRUE(p.unpackError);
	}

	TEST(PayloadRequest, DiscardBits)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(5);
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0xbf);
	ASSERT_EQ(p.bitCount, 8);
	p.discardBits();
	ASSERT_FALSE(p.unpackError);
	ASSERT_EQ(p.bitStream, 0);
	ASSERT_EQ(p.bitCount, 0);
	}

	TEST(PayloadRequest, FullyUnpacked)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	uint32_t v1;
	p.unpack(v1);
	// still one remaining byte
	ASSERT_FALSE(p.fullyUnpacked());
	p.fillBits(3);
	p.popBits(3);
	// still five remaining bits
	ASSERT_FALSE(p.fullyUnpacked());
	p.fillBits(5);
	p.popBits(5);
	// fully unpacked, should be no errors
	ASSERT_TRUE(p.fullyUnpacked());
	p.fillBits(4);
	// fullyUnpacked fails because an attempt to unpack too many bytes
	ASSERT_FALSE(p.fullyUnpacked());
	}

	TEST(PayloadRequest, ResetInternal)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	p.fillBits(4);
	p.unpackError = true;
	p.reset();
	ASSERT_EQ(p.rawIndex, 0);
	ASSERT_EQ(p.bitStream, 0);
	ASSERT_EQ(p.bitCount, 0);
	ASSERT_FALSE(p.unpackError);
	}

	TEST(PayloadRequest, ResetUsage)
	{
	// Payload.reset is used to rewind the unpacking to the initial
	// state. This is needed so that OEM commands can unpack the group
	// number or the IANA to determine which handler needs to be called
	std::vector<uint8_t> i = {0x04, 0x86};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	uint8_t v1;
	// check that the number of bytes matches
	ASSERT_EQ(p.unpack(v1), 0);
	// check that the payload was not fully unpacked
	ASSERT_FALSE(p.fullyUnpacked());
	uint8_t k1 = 0x04;
	// check that the bytes were correctly unpacked (LSB first)
	ASSERT_EQ(v1, k1);
	// do a reset on the payload
	p.reset();
	// unpack a uint16
	uint16_t v2;
	// check that the number of bytes matches
	ASSERT_EQ(p.unpack(v2), 0);
	// check that the payload was fully unpacked
	ASSERT_TRUE(p.fullyUnpacked());
	uint16_t k2 = 0x8604;
	// check that the bytes were correctly unpacked (LSB first)
	ASSERT_EQ(v2, k2);
	}

	TEST(PayloadRequest, PartialPayload)
	{
	std::vector<uint8_t> i = {0xbf, 0x04, 0x86, 0x00, 0x02};
	ipmi::message::Payload p(std::forward<std::vector<uint8_t>>(i));
	uint8_t v1;
	ipmi::message::Payload localPayload;
	// check that the number of bytes matches
	ASSERT_EQ(p.unpack(v1, localPayload), 0);
	// check that the payload was partially unpacked and not in error
	ASSERT_FALSE(p.fullyUnpacked());
	ASSERT_FALSE(p.unpackError);
	// check that the 'extracted' payload is not fully unpacked
	ASSERT_FALSE(localPayload.fullyUnpacked());
	uint8_t k1 = 0xbf;
	// check that the bytes were correctly unpacked (LSB first)
	ASSERT_EQ(v1, k1);
	uint32_t v2;
	// unpack using the 'extracted' payload
	ASSERT_EQ(localPayload.unpack(v2), 0);
	ASSERT_TRUE(localPayload.fullyUnpacked());
	uint32_t k2 = 0x02008604;
	ASSERT_EQ(v2, k2);
	}

	std::vector<std::string> logs;

	extern "C" {
	int sd_journal_send(const char* format, ...)
	{
	logs.push_back(format);
	return 0;
	}

	int sd_journal_send_with_location(const char* file, const char* line,
	const char* func, const char* format, ...)
	{
	logs.push_back(format);
	return 0;
	}
	}

	class PayloadLogging : public testing::Test
	{
	public:
	void SetUp()
	{
	logs.clear();
	}
	};

	TEST_F(PayloadLogging, TrailingOk)
	{
	{
	ipmi::message::Payload p({1, 2});
	}
	EXPECT_EQ(logs.size(), 0);
	}

	TEST_F(PayloadLogging, EnforcingUnchecked)
	{
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	}
	EXPECT_EQ(logs.size(), 1);
	}

	TEST_F(PayloadLogging, EnforcingUncheckedUnpacked)
	{
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	uint8_t out;
	p.unpack(out, out);
	}
	EXPECT_EQ(logs.size(), 1);
	}

	TEST_F(PayloadLogging, EnforcingUncheckedError)
	{
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	uint32_t out;
	p.unpack(out);
	}
	EXPECT_EQ(logs.size(), 0);
	}

	TEST_F(PayloadLogging, EnforcingChecked)
	{
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	EXPECT_FALSE(p.fullyUnpacked());
	}
	EXPECT_EQ(logs.size(), 0);
	}

	TEST_F(PayloadLogging, EnforcingCheckedUnpacked)
	{
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	uint8_t out;
	p.unpack(out, out);
	EXPECT_TRUE(p.fullyUnpacked());
	}
	EXPECT_EQ(logs.size(), 0);
	}

	TEST_F(PayloadLogging, EnforcingUnpackPayload)
	{
	{
	ipmi::message::Payload p;
	{
	ipmi::message::Payload q({1, 2});
	q.trailingOk = false;
	q.unpack(p);
	}
	EXPECT_EQ(logs.size(), 0);
	}
	EXPECT_EQ(logs.size(), 1);
	}

	TEST_F(PayloadLogging, EnforcingMove)
	{
	{
	ipmi::message::Payload p;
	{
	ipmi::message::Payload q({1, 2});
	q.trailingOk = false;
	p = std::move(q);
	}
	EXPECT_EQ(logs.size(), 0);
	}
	EXPECT_EQ(logs.size(), 1);
	}

	TEST_F(PayloadLogging, EnforcingException)
	{
	try
	{
	ipmi::message::Payload p({1, 2});
	p.trailingOk = false;
	throw std::runtime_error("test");
	}
	catch (...)
	{
	}
	EXPECT_EQ(logs.size(), 0);
	}