blob: 56d8d41426107de8ac72b5c5d9e4ac813665718c [file] [log] [blame]
/**
* 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);
}