path: root/test/message/payload.cpp

/**
 * 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);
}