blob: 57bff0663fe4fca9ce6502a081272a9d0c97a74c [file] [log] [blame]
Vernon Maueryebe8e902018-12-12 09:39:22 -08001/**
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
23TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070031 ipmi::SecureBuffer k = {0x04};
Vernon Maueryebe8e902018-12-12 09:39:22 -080032 ASSERT_EQ(p.raw, k);
33}
34
35TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070043 ipmi::SecureBuffer k = {0x04, 0x86};
Vernon Maueryebe8e902018-12-12 09:39:22 -080044 ASSERT_EQ(p.raw, k);
45}
46
47TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070055 ipmi::SecureBuffer k = {0x04, 0x86, 0x00, 0x02};
Vernon Maueryebe8e902018-12-12 09:39:22 -080056 ASSERT_EQ(p.raw, k);
57}
58
59TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070067 ipmi::SecureBuffer k = {0x04, 0x86, 0x00, 0x02, 0x44, 0x33, 0x22, 0x11};
Vernon Maueryebe8e902018-12-12 09:39:22 -080068 ASSERT_EQ(p.raw, k);
69}
70
71TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070079 ipmi::SecureBuffer k = {0x58, 0x23, 0x11};
Vernon Maueryebe8e902018-12-12 09:39:22 -080080 ASSERT_EQ(p.raw, k);
81}
82
83TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -070096 ipmi::SecureBuffer k = {0xc9};
Vernon Maueryebe8e902018-12-12 09:39:22 -080097 ASSERT_EQ(p.raw, k);
98}
99
100TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -0700111 ipmi::SecureBuffer k = {0xc9};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800112 ASSERT_EQ(p.raw, k);
113}
114
115TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -0700125 ipmi::SecureBuffer k = {0xc9};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800126 ASSERT_EQ(p.raw, k);
127}
128
129TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -0700140 ipmi::SecureBuffer k = {0xc9};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800141 ASSERT_EQ(p.raw, k);
142}
143
144TEST(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)
Vernon Mauery997952a2021-07-30 14:06:14 -0700155 ipmi::SecureBuffer k = {0x04, 0x86, 0x00, 0x02};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800156 ASSERT_EQ(p.raw, k);
157}
158
Vernon Mauery508c4572019-04-08 10:01:33 -0700159TEST(PackBasics, Tuple)
160{
161 // tuples are the new struct, pack a tuple
162 ipmi::message::Payload p;
163 auto v = std::make_tuple(static_cast<uint16_t>(0x8604), 'A');
164 p.pack(v);
165 // check that the number of bytes matches
166 ASSERT_EQ(p.size(), sizeof(uint16_t) + sizeof(char));
167 // check that the bytes were correctly packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700168 ipmi::SecureBuffer k = {0x04, 0x86, 0x41};
Vernon Mauery508c4572019-04-08 10:01:33 -0700169 ASSERT_EQ(p.raw, k);
170}
171
Vernon Maueryebe8e902018-12-12 09:39:22 -0800172TEST(PackBasics, Array4xUint8)
173{
174 // an array of bytes will be output verbatim, low-order element first
175 ipmi::message::Payload p;
176 std::array<uint8_t, 4> v = {{0x02, 0x00, 0x86, 0x04}};
177 p.pack(v);
178 // check that the number of bytes matches
179 ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
180 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700181 ipmi::SecureBuffer k = {0x02, 0x00, 0x86, 0x04};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800182 ASSERT_EQ(p.raw, k);
183}
184
185TEST(PackBasics, Array4xUint32)
186{
187 // an array of multi-byte values will be output in order low-order
188 // element first, each multi-byte element in LSByte order
189 // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
190 // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
191 // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
192 // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
193 ipmi::message::Payload p;
194 std::array<uint32_t, 4> v = {
195 {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
196 p.pack(v);
197 // check that the number of bytes matches
198 ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
199 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700200 ipmi::SecureBuffer k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
201 0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800202 ASSERT_EQ(p.raw, k);
203}
204
205TEST(PackBasics, VectorUint32)
206{
207 // a vector of multi-byte values will be output in order low-order
208 // element first, each multi-byte element in LSByte order
209 // v[0][7:0] v[0][15:9] v[0][23:16] v[0][31:24]
210 // v[1][7:0] v[1][15:9] v[1][23:16] v[1][31:24]
211 // v[2][7:0] v[2][15:9] v[2][23:16] v[2][31:24]
212 // v[3][7:0] v[3][15:9] v[3][23:16] v[3][31:24]
213 ipmi::message::Payload p;
214 std::vector<uint32_t> v = {
215 {0x11223344, 0x22446688, 0x33557799, 0x12345678}};
216 p.pack(v);
217 // check that the number of bytes matches
218 ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
219 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700220 ipmi::SecureBuffer k = {0x44, 0x33, 0x22, 0x11, 0x88, 0x66, 0x44, 0x22,
221 0x99, 0x77, 0x55, 0x33, 0x78, 0x56, 0x34, 0x12};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800222 ASSERT_EQ(p.raw, k);
223}
224
225TEST(PackBasics, VectorUint8)
226{
227 // a vector of bytes will be output verbatim, low-order element first
228 ipmi::message::Payload p;
229 std::vector<uint8_t> v = {0x02, 0x00, 0x86, 0x04};
230 p.pack(v);
231 // check that the number of bytes matches
232 ASSERT_EQ(p.size(), v.size() * sizeof(v[0]));
233 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700234 ipmi::SecureBuffer k = {0x02, 0x00, 0x86, 0x04};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800235 ASSERT_EQ(p.raw, k);
236}
237
William A. Kennington III906e0f82019-04-24 14:44:03 -0700238TEST(PackBasics, VectorUnaligned)
239{
240 ipmi::message::Payload p;
241 EXPECT_EQ(p.pack(true, std::vector<uint8_t>{1}), 1);
Vernon Mauery997952a2021-07-30 14:06:14 -0700242 EXPECT_EQ(p.raw, ipmi::SecureBuffer{0b1});
William A. Kennington III906e0f82019-04-24 14:44:03 -0700243}
244
William A. Kennington IIIe2aec262019-04-24 14:44:26 -0700245TEST(PackBasics, StringView)
246{
247 ipmi::message::Payload p;
248 EXPECT_EQ(p.pack(std::string_view{"\x24\x30\x11"}), 0);
Vernon Mauery997952a2021-07-30 14:06:14 -0700249 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0x24, 0x30, 0x11}));
William A. Kennington IIIe2aec262019-04-24 14:44:26 -0700250}
251
252TEST(PackBasics, StringViewUnaligned)
253{
254 ipmi::message::Payload p;
255 EXPECT_EQ(p.pack(true, std::string_view{"abc"}), 1);
Vernon Mauery997952a2021-07-30 14:06:14 -0700256 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1}));
William A. Kennington IIIe2aec262019-04-24 14:44:26 -0700257}
258
Vernon Mauerybae91352019-04-03 12:11:08 -0700259TEST(PackBasics, OptionalEmpty)
260{
261 // an optional will only pack if the value is present
262 ipmi::message::Payload p;
263 std::optional<uint32_t> v;
264 p.pack(v);
265 // check that the number of bytes matches
266 ASSERT_EQ(p.size(), 0);
267 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700268 ipmi::SecureBuffer k = {};
Vernon Mauerybae91352019-04-03 12:11:08 -0700269 ASSERT_EQ(p.raw, k);
270}
271
272TEST(PackBasics, OptionalContainsValue)
273{
274 // an optional will only pack if the value is present
275 ipmi::message::Payload p;
276 std::optional<uint32_t> v(0x04860002);
277 p.pack(v);
278 // check that the number of bytes matches
279 ASSERT_EQ(p.size(), sizeof(uint32_t));
280 // check that the bytes were correctly packed (in byte order)
Vernon Mauery997952a2021-07-30 14:06:14 -0700281 ipmi::SecureBuffer k = {0x02, 0x00, 0x86, 0x04};
Vernon Mauerybae91352019-04-03 12:11:08 -0700282 ASSERT_EQ(p.raw, k);
283}
284
William A. Kennington IIIe15e53e2019-04-24 14:45:20 -0700285TEST(PackBasics, Payload)
286{
287 ipmi::message::Payload p;
288 EXPECT_EQ(p.pack(true), 0);
289 EXPECT_EQ(p.pack(ipmi::message::Payload({0x24, 0x30})), 0);
Vernon Mauery997952a2021-07-30 14:06:14 -0700290 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1, 0x24, 0x30}));
William A. Kennington IIIe15e53e2019-04-24 14:45:20 -0700291}
292
293TEST(PackBasics, PayloadUnaligned)
294{
295 ipmi::message::Payload p;
296 EXPECT_EQ(p.pack(true, ipmi::message::Payload({0x24})), 1);
Vernon Mauery997952a2021-07-30 14:06:14 -0700297 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1}));
William A. Kennington IIIe15e53e2019-04-24 14:45:20 -0700298}
299
300TEST(PackBasics, PayloadOtherUnaligned)
301{
302 ipmi::message::Payload p, q;
303 q.appendBits(1, 1);
304 EXPECT_EQ(p.pack(true), 0);
305 EXPECT_EQ(p.pack(q), 1);
Vernon Mauery997952a2021-07-30 14:06:14 -0700306 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1}));
William A. Kennington IIIe15e53e2019-04-24 14:45:20 -0700307}
308
William A. Kennington III92476a82019-04-25 01:32:30 -0700309TEST(PackBasics, PrependPayload)
310{
311 ipmi::message::Payload p;
312 EXPECT_EQ(p.pack(true), 0);
313 EXPECT_EQ(p.prepend(ipmi::message::Payload({0x24, 0x30})), 0);
Vernon Mauery997952a2021-07-30 14:06:14 -0700314 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0x24, 0x30, 0b1}));
William A. Kennington III92476a82019-04-25 01:32:30 -0700315}
316
317TEST(PackBasics, PrependPayloadUnaligned)
318{
319 ipmi::message::Payload p;
320 p.appendBits(1, 1);
321 EXPECT_EQ(p.prepend(ipmi::message::Payload({0x24})), 1);
322 p.drain();
Vernon Mauery997952a2021-07-30 14:06:14 -0700323 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1}));
William A. Kennington III92476a82019-04-25 01:32:30 -0700324}
325
326TEST(PackBasics, PrependPayloadOtherUnaligned)
327{
328 ipmi::message::Payload p, q;
329 q.appendBits(1, 1);
330 EXPECT_EQ(p.pack(true), 0);
331 EXPECT_EQ(p.prepend(q), 1);
Vernon Mauery997952a2021-07-30 14:06:14 -0700332 EXPECT_EQ(p.raw, ipmi::SecureBuffer({0b1}));
William A. Kennington III92476a82019-04-25 01:32:30 -0700333}
334
Vernon Maueryebe8e902018-12-12 09:39:22 -0800335TEST(PackAdvanced, Uints)
336{
337 // all elements will be processed in order, with each multi-byte
338 // element being processed LSByte first
339 // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
340 // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
341 // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
342 ipmi::message::Payload p;
343 uint8_t v1 = 0x02;
344 uint16_t v2 = 0x0604;
345 uint32_t v3 = 0x44332211;
346 uint64_t v4 = 0xccbbaa9988776655ull;
347 p.pack(v1, v2, v3, v4);
348 // check that the number of bytes matches
349 ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
350 // check that the bytes were correctly packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700351 ipmi::SecureBuffer k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
352 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800353 ASSERT_EQ(p.raw, k);
354}
355
356TEST(PackAdvanced, TupleInts)
357{
358 // all elements will be processed in order, with each multi-byte
359 // element being processed LSByte first
360 // v1[7:0] v2[7:0] v2[15:8] v3[7:0] v3[15:8] v3[23:16] v3[31:24]
361 // v4[7:0] v4[15:8] v4[23:16] v4[31:24]
362 // v4[39:25] v4[47:40] v4[55:48] v4[63:56]
363 ipmi::message::Payload p;
364 uint8_t v1 = 0x02;
365 uint16_t v2 = 0x0604;
366 uint32_t v3 = 0x44332211;
367 uint64_t v4 = 0xccbbaa9988776655ull;
368 auto v = std::make_tuple(v1, v2, v3, v4);
369 p.pack(v);
370 // check that the number of bytes matches
371 ASSERT_EQ(p.size(), sizeof(v1) + sizeof(v2) + sizeof(v3) + sizeof(v4));
372 // check that the bytes were correctly packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700373 ipmi::SecureBuffer k = {0x02, 0x04, 0x06, 0x11, 0x22, 0x33, 0x44, 0x55,
374 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800375 ASSERT_EQ(p.raw, k);
376}
377
James Feistf2998072019-04-03 11:54:52 -0700378TEST(PackAdvanced, VariantArray)
379{
380 ipmi::message::Payload p;
381 std::variant<std::array<uint8_t, 2>, uint32_t> variant;
382 auto data = std::array<uint8_t, 2>{2, 4};
383 variant = data;
384
385 p.pack(variant);
386 ASSERT_EQ(p.size(), sizeof(data));
387
388 // check that the bytes were correctly packed packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700389 ipmi::SecureBuffer k = {2, 4};
James Feistf2998072019-04-03 11:54:52 -0700390 ASSERT_EQ(p.raw, k);
391}
392
Vernon Maueryebe8e902018-12-12 09:39:22 -0800393TEST(PackAdvanced, BoolsnBitfieldsnFixedIntsOhMy)
394{
395 // each element will be added, filling the low-order bits first
396 // with multi-byte values getting added LSByte first
397 // v1 will occupy k[0][1:0]
398 // v2 will occupy k[0][2]
399 // v3[4:0] will occupy k[0][7:3], v3[6:5] will occupy k[1][1:0]
400 // v4 will occupy k[1][2]
401 // v5 will occupy k[1][7:3]
402 ipmi::message::Payload p;
403 uint2_t v1 = 2; // binary 0b10
404 bool v2 = true; // binary 0b1
405 std::bitset<7> v3(0x73); // binary 0b1110011
406 bool v4 = false; // binary 0b0
407 uint5_t v5 = 27; // binary 0b11011
408 // concat binary: 0b1101101110011110 -> 0xdb9e -> 0x9e 0xdb (LSByte first)
409 p.pack(v1, v2, v3, v4, v5);
410 // check that the number of bytes matches
411 ASSERT_EQ(p.size(), sizeof(uint16_t));
412 // check that the bytes were correctly packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700413 ipmi::SecureBuffer k = {0x9e, 0xdb};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800414 ASSERT_EQ(p.raw, k);
415}
416
417TEST(PackAdvanced, UnalignedBitPacking)
418{
419 // unaligned multi-byte values will be packed the same as
420 // other bits, effectively building up a large value, low-order
421 // bits first, then outputting a stream of LSByte values
422 // v1 will occupy k[0][1:0]
423 // v2[5:0] will occupy k[0][7:2], v2[7:6] will occupy k[1][1:0]
424 // v3 will occupy k[1][2]
425 // v4[4:0] will occupy k[1][7:3] v4[12:5] will occupy k[2][7:0]
426 // v4[15:13] will occupy k[3][2:0]
427 // v5 will occupy k[3][3]
428 // v6[3:0] will occupy k[3][7:0] v6[11:4] will occupy k[4][7:0]
429 // v6[19:12] will occupy k[5][7:0] v6[27:20] will occupy k[6][7:0]
430 // v6[31:28] will occupy k[7][3:0]
431 // v7 will occupy k[7][7:4]
432 ipmi::message::Payload p;
433 uint2_t v1 = 2; // binary 0b10
434 uint8_t v2 = 0xa5; // binary 0b10100101
435 bool v3 = false; // binary 0b0
436 uint16_t v4 = 0xa55a; // binary 0b1010010101011010
437 bool v5 = true; // binary 0b1
438 uint32_t v6 = 0xdbc3bd3c; // binary 0b11011011110000111011110100111100
439 uint4_t v7 = 9; // binary 0b1001
440 // concat binary:
441 // 0b1001110110111100001110111101001111001101001010101101001010010110
442 // -> 0x9dbc3bd3cd2ad296 -> 0x96 0xd2 0x2a 0xcd 0xd3 0x3b 0xbc 0x9d
443 p.pack(v1, v2, v3, v4, v5, v6, v7);
444 // check that the number of bytes matches
445 ASSERT_EQ(p.size(), sizeof(uint64_t));
446 // check that the bytes were correctly packed (LSB first)
Vernon Mauery997952a2021-07-30 14:06:14 -0700447 ipmi::SecureBuffer k = {0x96, 0xd2, 0x2a, 0xcd, 0xd3, 0x3b, 0xbc, 0x9d};
Vernon Maueryebe8e902018-12-12 09:39:22 -0800448 ASSERT_EQ(p.raw, k);
449}
Vernon Mauery508c4572019-04-08 10:01:33 -0700450
451TEST(PackAdvanced, ComplexOptionalTuple)
452{
453 constexpr size_t macSize = 6;
454 // inspired from a real-world case of Get Session Info
455 constexpr uint8_t handle = 0x23; // handle for active session
456 constexpr uint8_t maxSessions = 15; // number of possible active sessions
457 constexpr uint8_t currentSessions = 4; // number of current active sessions
458 std::optional< // only returned for active session
459 std::tuple<uint8_t, // user ID
460 uint8_t, // privilege
461 uint4_t, // channel number
462 uint4_t // protocol (RMCP+)
463 >>
464 activeSession;
465 std::optional< // only returned for channel type LAN
466 std::tuple<uint32_t, // IPv4 address
467 std::array<uint8_t, macSize>, // MAC address
468 uint16_t // port
469 >>
470 lanSession;
471
472 constexpr uint8_t userID = 7;
473 constexpr uint8_t priv = 4;
474 constexpr uint4_t channel = 2;
475 constexpr uint4_t protocol = 1;
476 activeSession.emplace(userID, priv, channel, protocol);
477 constexpr std::array<uint8_t, macSize> macAddr{0};
478 lanSession.emplace(0x0a010105, macAddr, 55327);
479
480 ipmi::message::Payload p;
481 p.pack(handle, maxSessions, currentSessions, activeSession, lanSession);
Patrick Williams1318a5e2024-08-16 15:19:54 -0400482 ASSERT_EQ(p.size(),
483 sizeof(handle) + sizeof(maxSessions) + sizeof(currentSessions) +
484 3 * sizeof(uint8_t) + sizeof(uint32_t) +
485 sizeof(uint8_t) * macSize + sizeof(uint16_t));
486 uint8_t protocol_channel =
487 (static_cast<uint8_t>(protocol) << 4) | static_cast<uint8_t>(channel);
488 ipmi::SecureBuffer k = {
489 handle, maxSessions, currentSessions, userID, priv, protocol_channel,
490 // ip addr
491 0x05, 0x01, 0x01, 0x0a,
492 // mac addr
493 0, 0, 0, 0, 0, 0,
494 // port
495 0x1f, 0xd8};
Vernon Mauery508c4572019-04-08 10:01:33 -0700496 ASSERT_EQ(p.raw, k);
497}