1 /** 2 * Copyright © 2018 Intel Corporation 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #include <ipmid/api.hpp> 17 #include <ipmid/message.hpp> 18 19 #include <gtest/gtest.h> 20 21 // TODO: Add testing of Payload response API 22 23 TEST(PackBasics, Uint8) 24 { 25 ipmi::message::Payload p; 26 uint8_t v = 4; 27 p.pack(v); 28 // check that the number of bytes matches 29 ASSERT_EQ(p.size(), sizeof(v)); 30 // check that the bytes were correctly packed (LSB first) 31 std::vector<uint8_t> k = {0x04}; 32 ASSERT_EQ(p.raw, k); 33 } 34 35 TEST(PackBasics, Uint16) 36 { 37 ipmi::message::Payload p; 38 uint16_t v = 0x8604; 39 p.pack(v); 40 // check that the number of bytes matches 41 ASSERT_EQ(p.size(), sizeof(v)); 42 // check that the bytes were correctly packed (LSB first) 43 std::vector<uint8_t> k = {0x04, 0x86}; 44 ASSERT_EQ(p.raw, k); 45 } 46 47 TEST(PackBasics, Uint32) 48 { 49 ipmi::message::Payload p; 50 uint32_t v = 0x02008604; 51 p.pack(v); 52 // check that the number of bytes matches 53 ASSERT_EQ(p.size(), sizeof(v)); 54 // check that the bytes were correctly packed (LSB first) 55 std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02}; 56 ASSERT_EQ(p.raw, k); 57 } 58 59 TEST(PackBasics, Uint64) 60 { 61 ipmi::message::Payload p; 62 uint64_t v = 0x1122334402008604ull; 63 p.pack(v); 64 // check that the number of bytes matches 65 ASSERT_EQ(p.size(), sizeof(v)); 66 // check that the bytes were correctly packed (LSB first) 67 std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02, 0x44, 0x33, 0x22, 0x11}; 68 ASSERT_EQ(p.raw, k); 69 } 70 71 TEST(PackBasics, Uint24) 72 { 73 ipmi::message::Payload p; 74 uint24_t v = 0x112358; 75 p.pack(v); 76 // check that the number of bytes matches 77 ASSERT_EQ(p.size(), types::nrFixedBits<decltype(v)> / CHAR_BIT); 78 // check that the bytes were correctly packed (LSB first) 79 std::vector<uint8_t> k = {0x58, 0x23, 0x11}; 80 ASSERT_EQ(p.raw, k); 81 } 82 83 TEST(PackBasics, Uint3Uint5) 84 { 85 // individual bytes are packed low-order-bits first 86 // v1 will occupy [2:0], v2 will occupy [7:3] 87 ipmi::message::Payload p; 88 uint3_t v1 = 0x1; 89 uint5_t v2 = 0x19; 90 p.pack(v1, v2); 91 // check that the number of bytes matches 92 ASSERT_EQ(p.size(), (types::nrFixedBits<decltype(v1)> + 93 types::nrFixedBits<decltype(v2)>) / 94 CHAR_BIT); 95 // check that the bytes were correctly packed (LSB first) 96 std::vector<uint8_t> k = {0xc9}; 97 ASSERT_EQ(p.raw, k); 98 } 99 100 TEST(PackBasics, Boolx8) 101 { 102 // individual bytes are packed low-order-bits first 103 // [v8, v7, v6, v5, v4, v3, v2, v1] 104 ipmi::message::Payload p; 105 bool v8 = true, v7 = true, v6 = false, v5 = false; 106 bool v4 = true, v3 = false, v2 = false, v1 = true; 107 p.pack(v1, v2, v3, v4, v5, v6, v7, v8); 108 // check that the number of bytes matches 109 ASSERT_EQ(p.size(), sizeof(uint8_t)); 110 // check that the bytes were correctly packed (LSB first) 111 std::vector<uint8_t> k = {0xc9}; 112 ASSERT_EQ(p.raw, k); 113 } 114 115 TEST(PackBasics, Bitset8) 116 { 117 // individual bytes are packed low-order-bits first 118 // a bitset for 8 bits fills the full byte 119 ipmi::message::Payload p; 120 std::bitset<8> v(0xc9); 121 p.pack(v); 122 // check that the number of bytes matches 123 ASSERT_EQ(p.size(), v.size() / CHAR_BIT); 124 // check that the bytes were correctly packed (LSB first) 125 std::vector<uint8_t> k = {0xc9}; 126 ASSERT_EQ(p.raw, k); 127 } 128 129 TEST(PackBasics, Bitset3Bitset5) 130 { 131 // individual bytes are packed low-order-bits first 132 // v1 will occupy [2:0], v2 will occupy [7:3] 133 ipmi::message::Payload p; 134 std::bitset<3> v1(0x1); 135 std::bitset<5> v2(0x19); 136 p.pack(v1, v2); 137 // check that the number of bytes matches 138 ASSERT_EQ(p.size(), (v1.size() + v2.size()) / CHAR_BIT); 139 // check that the bytes were correctly packed (LSB first) 140 std::vector<uint8_t> k = {0xc9}; 141 ASSERT_EQ(p.raw, k); 142 } 143 144 TEST(PackBasics, Bitset32) 145 { 146 // individual bytes are packed low-order-bits first 147 // v1 will occupy 4 bytes, but in LSByte first order 148 // v1[7:0] v1[15:9] v1[23:16] v1[31:24] 149 ipmi::message::Payload p; 150 std::bitset<32> v(0x02008604); 151 p.pack(v); 152 // check that the number of bytes matches 153 ASSERT_EQ(p.size(), v.size() / CHAR_BIT); 154 // check that the bytes were correctly packed (LSB first) 155 std::vector<uint8_t> k = {0x04, 0x86, 0x00, 0x02}; 156 ASSERT_EQ(p.raw, k); 157 } 158 159 TEST(PackBasics, Array4xUint8) 160 { 161 // an array of bytes will be output verbatim, low-order element first 162 ipmi::message::Payload p; 163 std::array<uint8_t, 4> v = {{0x02, 0x00, 0x86, 0x04}}; 164 p.pack(v); 165 // check that the number of bytes matches 166 ASSERT_EQ(p.size(), v.size() * sizeof(v[0])); 167 // check that the bytes were correctly packed (in byte order) 168 std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04}; 169 ASSERT_EQ(p.raw, k); 170 } 171 172 TEST(PackBasics, Array4xUint32) 173 { 174 // an array of multi-byte values will be output in order low-order 175 // element first, each multi-byte element in LSByte order 176 // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24] 177 // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24] 178 // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24] 179 // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24] 180 ipmi::message::Payload p; 181 std::array<uint32_t, 4> v = { 182 {0x11223344, 0x22446688, 0x33557799, 0x12345678}}; 183 p.pack(v); 184 // check that the number of bytes matches 185 ASSERT_EQ(p.size(), v.size() * sizeof(v[0])); 186 // check that the bytes were correctly packed (in byte order) 187 std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22, 188 0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12}; 189 ASSERT_EQ(p.raw, k); 190 } 191 192 TEST(PackBasics, VectorUint32) 193 { 194 // a vector of multi-byte values will be output in order low-order 195 // element first, each multi-byte element in LSByte order 196 // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24] 197 // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24] 198 // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24] 199 // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24] 200 ipmi::message::Payload p; 201 std::vector<uint32_t> v = { 202 {0x11223344, 0x22446688, 0x33557799, 0x12345678}}; 203 p.pack(v); 204 // check that the number of bytes matches 205 ASSERT_EQ(p.size(), v.size() * sizeof(v[0])); 206 // check that the bytes were correctly packed (in byte order) 207 std::vector<uint8_t> k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22, 208 0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12}; 209 ASSERT_EQ(p.raw, k); 210 } 211 212 TEST(PackBasics, VectorUint8) 213 { 214 // a vector of bytes will be output verbatim, low-order element first 215 ipmi::message::Payload p; 216 std::vector<uint8_t> v = {0x02, 0x00, 0x86, 0x04}; 217 p.pack(v); 218 // check that the number of bytes matches 219 ASSERT_EQ(p.size(), v.size() * sizeof(v[0])); 220 // check that the bytes were correctly packed (in byte order) 221 std::vector<uint8_t> k = {0x02, 0x00, 0x86, 0x04}; 222 ASSERT_EQ(p.raw, k); 223 } 224 225 TEST(PackAdvanced, Uints) 226 { 227 // all elements will be processed in order, with each multi-byte 228 // element being processed LSByte first 229 // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24] 230 // v4[7:0] v4[15:8] v4[23:16] v4[31:24] 231 // v4[39:25] v4[47:40] v4[55:48] v4[63:56] 232 ipmi::message::Payload p; 233 uint8_t v1 = 0x02; 234 uint16_t v2 = 0x0604; 235 uint32_t v3 = 0x44332211; 236 uint64_t v4 = 0xccbbaa9988776655ull; 237 p.pack(v1, v2, v3, v4); 238 // check that the number of bytes matches 239 ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4)); 240 // check that the bytes were correctly packed (LSB first) 241 std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55, 242 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc}; 243 ASSERT_EQ(p.raw, k); 244 } 245 246 TEST(PackAdvanced, TupleInts) 247 { 248 // all elements will be processed in order, with each multi-byte 249 // element being processed LSByte first 250 // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24] 251 // v4[7:0] v4[15:8] v4[23:16] v4[31:24] 252 // v4[39:25] v4[47:40] v4[55:48] v4[63:56] 253 ipmi::message::Payload p; 254 uint8_t v1 = 0x02; 255 uint16_t v2 = 0x0604; 256 uint32_t v3 = 0x44332211; 257 uint64_t v4 = 0xccbbaa9988776655ull; 258 auto v = std::make_tuple(v1, v2, v3, v4); 259 p.pack(v); 260 // check that the number of bytes matches 261 ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4)); 262 // check that the bytes were correctly packed (LSB first) 263 std::vector<uint8_t> k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55, 264 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc}; 265 ASSERT_EQ(p.raw, k); 266 } 267 268 TEST(PackAdvanced, BoolsnBitfieldsnFixedIntsOhMy) 269 { 270 // each element will be added, filling the low-order bits first 271 // with multi-byte values getting added LSByte first 272 // v1 will occupy k[0][1:0] 273 // v2 will occupy k[0][2] 274 // v3[4:0] will occupy k[0][7:3], v3[6:5] will occupy k[1][1:0] 275 // v4 will occupy k[1][2] 276 // v5 will occupy k[1][7:3] 277 ipmi::message::Payload p; 278 uint2_t v1 = 2; // binary 0b10 279 bool v2 = true; // binary 0b1 280 std::bitset<7> v3(0x73); // binary 0b1110011 281 bool v4 = false; // binary 0b0 282 uint5_t v5 = 27; // binary 0b11011 283 // concat binary: 0b1101101110011110 -> 0xdb9e -> 0x9e 0xdb (LSByte first) 284 p.pack(v1, v2, v3, v4, v5); 285 // check that the number of bytes matches 286 ASSERT_EQ(p.size(), sizeof(uint16_t)); 287 // check that the bytes were correctly packed (LSB first) 288 std::vector<uint8_t> k = {0x9e, 0xdb}; 289 ASSERT_EQ(p.raw, k); 290 } 291 292 TEST(PackAdvanced, UnalignedBitPacking) 293 { 294 // unaligned multi-byte values will be packed the same as 295 // other bits, effectively building up a large value, low-order 296 // bits first, then outputting a stream of LSByte values 297 // v1 will occupy k[0][1:0] 298 // v2[5:0] will occupy k[0][7:2], v2[7:6] will occupy k[1][1:0] 299 // v3 will occupy k[1][2] 300 // v4[4:0] will occupy k[1][7:3] v4[12:5] will occupy k[2][7:0] 301 // v4[15:13] will occupy k[3][2:0] 302 // v5 will occupy k[3][3] 303 // v6[3:0] will occupy k[3][7:0] v6[11:4] will occupy k[4][7:0] 304 // v6[19:12] will occupy k[5][7:0] v6[27:20] will occupy k[6][7:0] 305 // v6[31:28] will occupy k[7][3:0] 306 // v7 will occupy k[7][7:4] 307 ipmi::message::Payload p; 308 uint2_t v1 = 2; // binary 0b10 309 uint8_t v2 = 0xa5; // binary 0b10100101 310 bool v3 = false; // binary 0b0 311 uint16_t v4 = 0xa55a; // binary 0b1010010101011010 312 bool v5 = true; // binary 0b1 313 uint32_t v6 = 0xdbc3bd3c; // binary 0b11011011110000111011110100111100 314 uint4_t v7 = 9; // binary 0b1001 315 // concat binary: 316 // 0b1001110110111100001110111101001111001101001010101101001010010110 317 // -> 0x9dbc3bd3cd2ad296 -> 0x96 0xd2 0x2a 0xcd 0xd3 0x3b 0xbc 0x9d 318 p.pack(v1, v2, v3, v4, v5, v6, v7); 319 // check that the number of bytes matches 320 ASSERT_EQ(p.size(), sizeof(uint64_t)); 321 // check that the bytes were correctly packed (LSB first) 322 std::vector<uint8_t> k = {0x96, 0xd2, 0x2a, 0xcd, 0xd3, 0x3b, 0xbc, 0x9d}; 323 ASSERT_EQ(p.raw, k); 324 } 325