test/message/pack.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.
 */
#include <ipmid/api.hpp>
#include <ipmid/message.hpp>

#include <gtest/gtest.h>

// TODO: Add testing of Payload response API

TEST(PackBasics, Uint8)
{
    ipmi::message::Payload p;
    uint8_t v = 4;
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x04};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Uint16)
{
    ipmi::message::Payload p;
    uint16_t v = 0x8604;
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x04, 0x86};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Uint32)
{
    ipmi::message::Payload p;
    uint32_t v = 0x02008604;
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Uint64)
{
    ipmi::message::Payload p;
    uint64_t v = 0x1122334402008604ull;
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02, 0x44, 0x33, 0x22, 0x11};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Uint24)
{
    ipmi::message::Payload p;
    uint24_t v = 0x112358;
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), types::nrFixedBits<decltype(v)> / CHAR_BIT);
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x58, 0x23, 0x11};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Uint3Uint5)
{
    // individual bytes are packed low-order-bits first
    // v1 will occupy [2:0], v2 will occupy [7:3]
    ipmi::message::Payload p;
    uint3_t v1 = 0x1;
    uint5_t v2 = 0x19;
    p.pack(v1, v2);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), (types::nrFixedBits<decltype(v1)> +
                         types::nrFixedBits<decltype(v2)>) /
                            CHAR_BIT);
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0xc9};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Boolx8)
{
    // individual bytes are packed low-order-bits first
    // [v8, v7, v6, v5, v4, v3, v2, v1]
    ipmi::message::Payload p;
    bool v8 = true, v7 = true, v6 = false, v5 = false;
    bool v4 = true, v3 = false, v2 = false, v1 = true;
    p.pack(v1, v2, v3, v4, v5, v6, v7, v8);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(uint8_t));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0xc9};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Bitset8)
{
    // individual bytes are packed low-order-bits first
    // a bitset for 8 bits fills the full byte
    ipmi::message::Payload p;
    std::bitset<8> v(0xc9);
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() / CHAR_BIT);
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0xc9};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Bitset3Bitset5)
{
    // individual bytes are packed low-order-bits first
    // v1 will occupy [2:0], v2 will occupy [7:3]
    ipmi::message::Payload p;
    std::bitset<3> v1(0x1);
    std::bitset<5> v2(0x19);
    p.pack(v1, v2);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), (v1.size() + v2.size()) / CHAR_BIT);
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0xc9};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Bitset32)
{
    // individual bytes are packed low-order-bits first
    // v1 will occupy 4 bytes, but in LSByte first order
    // v1[7:0] v1[15:9] v1[23:16] v1[31:24]
    ipmi::message::Payload p;
    std::bitset<32> v(0x02008604);
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() / CHAR_BIT);
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Array4xUint8)
{
    // an array of bytes will be output verbatim, low-order element first
    ipmi::message::Payload p;
    std::array<uint8_t, 4> v = {{0x02, 0x00, 0x86, 0x04}};
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
    // check that the bytes were correctly packed (in byte order)
    std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, Array4xUint32)
{
    // an array of multi-byte values will be output in order low-order
    // element first, each multi-byte element in LSByte order
    // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
    // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
    // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
    // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
    ipmi::message::Payload p;
    std::array<uint32_t, 4> v = {
        {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
    // check that the bytes were correctly packed (in byte order)
    std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
                              0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, VectorUint32)
{
    // a vector of multi-byte values will be output in order low-order
    // element first, each multi-byte element in LSByte order
    // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
    // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
    // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
    // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
    ipmi::message::Payload p;
    std::vector<uint32_t> v = {
        {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
    // check that the bytes were correctly packed (in byte order)
    std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
                              0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
    ASSERT_EQ(p.raw, k);
}

TEST(PackBasics, VectorUint8)
{
    // a vector of bytes will be output verbatim, low-order element first
    ipmi::message::Payload p;
    std::vector<uint8_t> v = {0x02, 0x00, 0x86, 0x04};
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
    // check that the bytes were correctly packed (in byte order)
    std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04};
    ASSERT_EQ(p.raw, k);
}

TEST(PackAdvanced, Uints)
{
    // all elements will be processed in order, with each multi-byte
    // element being processed LSByte first
    // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
    // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
    // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
    ipmi::message::Payload p;
    uint8_t v1 = 0x02;
    uint16_t v2 = 0x0604;
    uint32_t v3 = 0x44332211;
    uint64_t v4 = 0xccbbaa9988776655ull;
    p.pack(v1, v2, v3, v4);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
                              0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
    ASSERT_EQ(p.raw, k);
}

TEST(PackAdvanced, TupleInts)
{
    // all elements will be processed in order, with each multi-byte
    // element being processed LSByte first
    // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
    // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
    // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
    ipmi::message::Payload p;
    uint8_t v1 = 0x02;
    uint16_t v2 = 0x0604;
    uint32_t v3 = 0x44332211;
    uint64_t v4 = 0xccbbaa9988776655ull;
    auto v = std::make_tuple(v1, v2, v3, v4);
    p.pack(v);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
                              0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
    ASSERT_EQ(p.raw, k);
}

TEST(PackAdvanced, BoolsnBitfieldsnFixedIntsOhMy)
{
    // each element will be added, filling the low-order bits first
    // with multi-byte values getting added LSByte first
    // v1 will occupy k[0][1:0]
    // v2 will occupy k[0][2]
    // v3[4:0] will occupy k[0][7:3], v3[6:5] will occupy k[1][1:0]
    // v4 will occupy k[1][2]
    // v5 will occupy k[1][7:3]
    ipmi::message::Payload p;
    uint2_t v1 = 2;          // binary 0b10
    bool v2 = true;          // binary 0b1
    std::bitset<7> v3(0x73); // binary 0b1110011
    bool v4 = false;         // binary 0b0
    uint5_t v5 = 27;         // binary 0b11011
    // concat binary: 0b1101101110011110 -> 0xdb9e -> 0x9e 0xdb (LSByte first)
    p.pack(v1, v2, v3, v4, v5);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(uint16_t));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x9e, 0xdb};
    ASSERT_EQ(p.raw, k);
}

TEST(PackAdvanced, UnalignedBitPacking)
{
    // unaligned multi-byte values will be packed the same as
    // other bits, effectively building up a large value, low-order
    // bits first, then outputting a stream of LSByte values
    // v1 will occupy k[0][1:0]
    // v2[5:0] will occupy k[0][7:2], v2[7:6] will occupy k[1][1:0]
    // v3 will occupy k[1][2]
    // v4[4:0] will occupy k[1][7:3] v4[12:5] will occupy k[2][7:0]
    // v4[15:13] will occupy k[3][2:0]
    // v5 will occupy k[3][3]
    // v6[3:0] will occupy k[3][7:0] v6[11:4] will occupy k[4][7:0]
    // v6[19:12] will occupy k[5][7:0] v6[27:20] will occupy k[6][7:0]
    // v6[31:28] will occupy k[7][3:0]
    // v7 will occupy k[7][7:4]
    ipmi::message::Payload p;
    uint2_t v1 = 2;           // binary 0b10
    uint8_t v2 = 0xa5;        // binary 0b10100101
    bool v3 = false;          // binary 0b0
    uint16_t v4 = 0xa55a;     // binary 0b1010010101011010
    bool v5 = true;           // binary 0b1
    uint32_t v6 = 0xdbc3bd3c; // binary 0b11011011110000111011110100111100
    uint4_t v7 = 9;           // binary 0b1001
    // concat binary:
    //   0b1001110110111100001110111101001111001101001010101101001010010110
    //   -> 0x9dbc3bd3cd2ad296 -> 0x96 0xd2 0x2a 0xcd 0xd3 0x3b 0xbc 0x9d
    p.pack(v1, v2, v3, v4, v5, v6, v7);
    // check that the number of bytes matches
    ASSERT_EQ(p.size(), sizeof(uint64_t));
    // check that the bytes were correctly packed (LSB first)
    std::vector<uint8_t> k = {0x96, 0xd2, 0x2a, 0xcd, 0xd3, 0x3b, 0xbc, 0x9d};
    ASSERT_EQ(p.raw, k);
}