blob: b4a60227fcc802f08295e887b6bb7b78bf4cca81 [file] [log] [blame]
John Wang871c9272019-12-09 18:02:15 +08001#include <endian.h>
John Wang02700402019-10-06 16:34:29 +08002#include <string.h>
3
4#include <cstring>
John Wang50218a62020-02-12 17:10:28 +08005#include <string>
John Wangccc04552019-10-14 14:28:25 +08006#include <utility>
John Wang02700402019-10-06 16:34:29 +08007#include <vector>
8
9#include "libpldm/base.h"
10#include "libpldm/bios.h"
11#include "libpldm/bios_table.h"
John Wang871c9272019-12-09 18:02:15 +080012#include "libpldm/utils.h"
John Wang02700402019-10-06 16:34:29 +080013
John Wang49484a12019-12-02 14:21:53 +080014#include <gmock/gmock.h>
John Wang02700402019-10-06 16:34:29 +080015#include <gtest/gtest.h>
16
John Wang49484a12019-12-02 14:21:53 +080017using testing::ElementsAreArray;
John Wang02700402019-10-06 16:34:29 +080018using Table = std::vector<uint8_t>;
19
20void buildTable(Table& table)
21{
22 auto padSize = ((table.size() % 4) ? (4 - table.size() % 4) : 0);
23 table.insert(table.end(), padSize, 0);
John Wang871c9272019-12-09 18:02:15 +080024 uint32_t checksum = crc32(table.data(), table.size());
25 checksum = htole32(checksum);
26 uint8_t a[4];
27 std::memcpy(a, &checksum, sizeof(checksum));
28 table.insert(table.end(), std::begin(a), std::end(a));
John Wang02700402019-10-06 16:34:29 +080029}
30
31template <typename First, typename... Rest>
32void buildTable(Table& table, First& first, Rest&... rest)
33{
34 table.insert(table.end(), first.begin(), first.end());
35 buildTable(table, rest...);
36}
37
John Wangb0da7a02020-01-07 16:55:00 +080038TEST(AttrTable, HeaderDecodeTest)
39{
40 std::vector<uint8_t> enumEntry{
41 2, 0, /* attr handle */
42 0, /* attr type */
43 1, 0, /* attr name handle (string handle) */
44 2, /* number of possible value */
45 2, 0, /* possible value handle */
46 3, 0, /* possible value handle */
47 1, /* number of default value */
48 0 /* defaut value string handle index */
49 };
50 auto entry =
51 reinterpret_cast<struct pldm_bios_attr_table_entry*>(enumEntry.data());
52 auto attrHandle = pldm_bios_table_attr_entry_decode_attribute_handle(entry);
53 EXPECT_EQ(attrHandle, 2);
John Wang50218a62020-02-12 17:10:28 +080054 auto attrType = pldm_bios_table_attr_entry_decode_attribute_type(entry);
55 EXPECT_EQ(attrType, 0);
John Wangb0da7a02020-01-07 16:55:00 +080056 auto stringHandle = pldm_bios_table_attr_entry_decode_string_handle(entry);
57 EXPECT_EQ(stringHandle, 1);
58}
59
John Wang02700402019-10-06 16:34:29 +080060TEST(AttrTable, EnumEntryDecodeTest)
61{
62 std::vector<uint8_t> enumEntry{
63 0, 0, /* attr handle */
64 0, /* attr type */
65 1, 0, /* attr name handle */
66 2, /* number of possible value */
67 2, 0, /* possible value handle */
68 3, 0, /* possible value handle */
69 1, /* number of default value */
John Wang50218a62020-02-12 17:10:28 +080070 1 /* defaut value string handle index */
John Wang02700402019-10-06 16:34:29 +080071 };
72
73 auto entry =
74 reinterpret_cast<struct pldm_bios_attr_table_entry*>(enumEntry.data());
75 uint8_t pvNumber = pldm_bios_table_attr_entry_enum_decode_pv_num(entry);
76 EXPECT_EQ(pvNumber, 2);
John Wang02700402019-10-06 16:34:29 +080077 pvNumber = 0;
78 auto rc =
79 pldm_bios_table_attr_entry_enum_decode_pv_num_check(entry, &pvNumber);
80 EXPECT_EQ(rc, PLDM_SUCCESS);
81 EXPECT_EQ(pvNumber, 2);
John Wang3ad21752019-10-06 16:42:21 +080082
83 std::vector<uint16_t> pvHandles(pvNumber, 0);
84 pvNumber = pldm_bios_table_attr_entry_enum_decode_pv_hdls(
85 entry, pvHandles.data(), pvHandles.size());
86 EXPECT_EQ(pvNumber, 2);
87 EXPECT_EQ(pvHandles[0], 2);
88 EXPECT_EQ(pvHandles[1], 3);
89 pvHandles.resize(1);
90 pvNumber = pldm_bios_table_attr_entry_enum_decode_pv_hdls(
91 entry, pvHandles.data(), pvHandles.size());
92 EXPECT_EQ(pvNumber, 1);
93 EXPECT_EQ(pvHandles[0], 2);
94
95 pvHandles.resize(2);
96 rc = pldm_bios_table_attr_entry_enum_decode_pv_hdls_check(
97 entry, pvHandles.data(), pvHandles.size());
98 EXPECT_EQ(rc, PLDM_SUCCESS);
99 EXPECT_EQ(pvHandles[0], 2);
100 EXPECT_EQ(pvHandles[1], 3);
101 rc = pldm_bios_table_attr_entry_enum_decode_pv_hdls_check(
102 entry, pvHandles.data(), 1);
103 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
104
105 uint8_t defNumber = pldm_bios_table_attr_entry_enum_decode_def_num(entry);
106 EXPECT_EQ(defNumber, 1);
John Wang50218a62020-02-12 17:10:28 +0800107 std::vector<uint8_t> defIndices(defNumber);
108 rc = pldm_bios_table_attr_entry_enum_decode_def_indices(
109 entry, defIndices.data(), defIndices.size());
110 EXPECT_EQ(rc, defNumber);
111 EXPECT_THAT(defIndices, ElementsAreArray({1}));
112
John Wang02700402019-10-06 16:34:29 +0800113 defNumber = 0;
114 rc =
115 pldm_bios_table_attr_entry_enum_decode_def_num_check(entry, &defNumber);
116 EXPECT_EQ(rc, PLDM_SUCCESS);
117 EXPECT_EQ(defNumber, 1);
118
119 rc =
120 pldm_bios_table_attr_entry_enum_decode_pv_num_check(nullptr, &pvNumber);
121 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
122 rc = pldm_bios_table_attr_entry_enum_decode_def_num_check(entry, nullptr);
123 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
124
125 entry->attr_type = PLDM_BIOS_STRING;
126 rc = pldm_bios_table_attr_entry_enum_decode_pv_num_check(entry, &pvNumber);
127 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
128
129 rc =
130 pldm_bios_table_attr_entry_enum_decode_def_num_check(entry, &defNumber);
131 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
John Wang3ad21752019-10-06 16:42:21 +0800132 rc =
133 pldm_bios_table_attr_entry_enum_decode_pv_hdls_check(entry, nullptr, 0);
134 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
John Wang02700402019-10-06 16:34:29 +0800135}
136
John Wangccc04552019-10-14 14:28:25 +0800137TEST(AttrTable, EnumEntryEncodeTest)
138{
139 std::vector<uint8_t> enumEntry{
140 0, 0, /* attr handle */
141 0, /* attr type */
142 1, 0, /* attr name handle */
143 2, /* number of possible value */
144 2, 0, /* possible value handle */
145 3, 0, /* possible value handle */
146 1, /* number of default value */
147 0 /* defaut value string handle index */
148 };
149
150 std::vector<uint16_t> pv_hdls{2, 3};
151 std::vector<uint8_t> defs{0};
152
153 struct pldm_bios_table_attr_entry_enum_info info = {
154 1, /* name handle */
155 false, /* read only */
156 2, /* pv number */
157 pv_hdls.data(), /* pv handle */
158 1, /*def number */
159 defs.data() /*def index*/
160 };
161 auto encodeLength = pldm_bios_table_attr_entry_enum_encode_length(2, 1);
162 EXPECT_EQ(encodeLength, enumEntry.size());
163
164 std::vector<uint8_t> encodeEntry(encodeLength, 0);
165 pldm_bios_table_attr_entry_enum_encode(encodeEntry.data(),
166 encodeEntry.size(), &info);
167 // set attr handle = 0
168 encodeEntry[0] = 0;
169 encodeEntry[1] = 0;
170
171 EXPECT_EQ(enumEntry, encodeEntry);
172
173 EXPECT_DEATH(pldm_bios_table_attr_entry_enum_encode(
174 encodeEntry.data(), encodeEntry.size() - 1, &info),
175 "length <= entry_length");
176 auto rc = pldm_bios_table_attr_entry_enum_encode_check(
177 encodeEntry.data(), encodeEntry.size(), &info);
178 EXPECT_EQ(rc, PLDM_SUCCESS);
179 // set attr handle = 0
180 encodeEntry[0] = 0;
181 encodeEntry[1] = 0;
182
183 EXPECT_EQ(enumEntry, encodeEntry);
184 rc = pldm_bios_table_attr_entry_enum_encode_check(
185 encodeEntry.data(), encodeEntry.size() - 1, &info);
186 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
187}
188
John Wang02700402019-10-06 16:34:29 +0800189TEST(AttrTable, StringEntryDecodeTest)
190{
191 std::vector<uint8_t> stringEntry{
192 1, 0, /* attr handle */
193 1, /* attr type */
194 12, 0, /* attr name handle */
195 1, /* string type */
196 1, 0, /* minimum length of the string in bytes */
197 100, 0, /* maximum length of the string in bytes */
198 3, 0, /* length of default string in length */
199 'a', 'b', 'c' /* default string */
200 };
201
202 auto entry = reinterpret_cast<struct pldm_bios_attr_table_entry*>(
203 stringEntry.data());
John Wangb0da7a02020-01-07 16:55:00 +0800204 auto stringType =
205 pldm_bios_table_attr_entry_string_decode_string_type(entry);
206 EXPECT_EQ(stringType, 1);
John Wang50218a62020-02-12 17:10:28 +0800207 auto minLength = pldm_bios_table_attr_entry_string_decode_min_length(entry);
208 EXPECT_EQ(minLength, 1);
209 auto maxLength = pldm_bios_table_attr_entry_string_decode_max_length(entry);
210 EXPECT_EQ(maxLength, 100);
John Wangb0da7a02020-01-07 16:55:00 +0800211
John Wang50218a62020-02-12 17:10:28 +0800212 uint16_t defStringLength =
John Wang02700402019-10-06 16:34:29 +0800213 pldm_bios_table_attr_entry_string_decode_def_string_length(entry);
John Wang50218a62020-02-12 17:10:28 +0800214 EXPECT_EQ(defStringLength, 3);
215 std::vector<char> defString(defStringLength + 1);
216 auto rc = pldm_bios_table_attr_entry_string_decode_def_string(
217 entry, defString.data(), defString.size());
218 EXPECT_EQ(rc, 3);
219 EXPECT_STREQ(defString.data(), "abc");
220 rc = pldm_bios_table_attr_entry_string_decode_def_string(
221 entry, defString.data(), defString.size() - 1);
222 EXPECT_EQ(rc, 2);
223 EXPECT_STREQ(defString.data(), "ab");
John Wang02700402019-10-06 16:34:29 +0800224
John Wang50218a62020-02-12 17:10:28 +0800225 defStringLength = 0;
226 rc = pldm_bios_table_attr_entry_string_decode_def_string_length_check(
227 entry, &defStringLength);
John Wang02700402019-10-06 16:34:29 +0800228 EXPECT_EQ(rc, PLDM_SUCCESS);
John Wang50218a62020-02-12 17:10:28 +0800229 EXPECT_EQ(defStringLength, 3);
John Wang02700402019-10-06 16:34:29 +0800230
231 rc = pldm_bios_table_attr_entry_string_decode_def_string_length_check(
232 entry, nullptr);
233 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
234 rc = pldm_bios_table_attr_entry_string_decode_def_string_length_check(
John Wang50218a62020-02-12 17:10:28 +0800235 nullptr, &defStringLength);
John Wang02700402019-10-06 16:34:29 +0800236 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
237 entry->attr_type = PLDM_BIOS_INTEGER;
238 rc = pldm_bios_table_attr_entry_string_decode_def_string_length_check(
John Wang50218a62020-02-12 17:10:28 +0800239 entry, &defStringLength);
John Wang02700402019-10-06 16:34:29 +0800240 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
241 rc = pldm_bios_table_attr_entry_string_decode_def_string_length_check(
John Wang50218a62020-02-12 17:10:28 +0800242 nullptr, &defStringLength);
John Wang02700402019-10-06 16:34:29 +0800243 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
244}
245
John Wangccc04552019-10-14 14:28:25 +0800246TEST(AttrTable, StringEntryEncodeTest)
247{
248 std::vector<uint8_t> stringEntry{
249 0, 0, /* attr handle */
250 1, /* attr type */
251 3, 0, /* attr name handle */
252 1, /* string type */
253 1, 0, /* min string length */
254 100, 0, /* max string length */
255 3, 0, /* default string length */
256 'a', 'b', 'c', /* defaul string */
257 };
258
259 struct pldm_bios_table_attr_entry_string_info info = {
260 3, /* name handle */
261 false, /* read only */
262 1, /* string type ascii */
263 1, /* min length */
264 100, /* max length */
265 3, /* def length */
266 "abc", /* def string */
267 };
268 auto encodeLength = pldm_bios_table_attr_entry_string_encode_length(3);
269 EXPECT_EQ(encodeLength, stringEntry.size());
270
271 std::vector<uint8_t> encodeEntry(encodeLength, 0);
272 pldm_bios_table_attr_entry_string_encode(encodeEntry.data(),
273 encodeEntry.size(), &info);
274 // set attr handle = 0
275 encodeEntry[0] = 0;
276 encodeEntry[1] = 0;
277
278 EXPECT_EQ(stringEntry, encodeEntry);
279
280 EXPECT_DEATH(pldm_bios_table_attr_entry_string_encode(
281 encodeEntry.data(), encodeEntry.size() - 1, &info),
282 "length <= entry_length");
283 auto rc = pldm_bios_table_attr_entry_string_encode_check(
284 encodeEntry.data(), encodeEntry.size(), &info);
285 EXPECT_EQ(rc, PLDM_SUCCESS);
286 // set attr handle = 0
287 encodeEntry[0] = 0;
288 encodeEntry[1] = 0;
289
290 EXPECT_EQ(stringEntry, encodeEntry);
291 rc = pldm_bios_table_attr_entry_string_encode_check(
292 encodeEntry.data(), encodeEntry.size() - 1, &info);
293 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
294 std::swap(info.max_length, info.min_length);
John Wang827c5de2019-11-07 18:27:27 +0800295 const char* errmsg;
296 rc = pldm_bios_table_attr_entry_string_info_check(&info, &errmsg);
297 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
298 EXPECT_STREQ(
299 "MinimumStingLength should not be greater than MaximumStringLength",
300 errmsg);
John Wangccc04552019-10-14 14:28:25 +0800301 rc = pldm_bios_table_attr_entry_string_encode_check(
302 encodeEntry.data(), encodeEntry.size(), &info);
303 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
304 std::swap(info.max_length, info.min_length);
305
306 std::vector<uint8_t> stringEntryLength0{
307 0, 0, /* attr handle */
308 1, /* attr type */
309 3, 0, /* attr name handle */
310 1, /* string type */
311 1, 0, /* min string length */
312 100, 0, /* max string length */
313 0, 0, /* default string length */
314 };
315
316 info.def_length = 0;
317 info.def_string = nullptr;
318
319 encodeLength = pldm_bios_table_attr_entry_string_encode_length(0);
320 EXPECT_EQ(encodeLength, stringEntryLength0.size());
321
322 encodeEntry.resize(encodeLength);
323 pldm_bios_table_attr_entry_string_encode(encodeEntry.data(),
324 encodeEntry.size(), &info);
325 // set attr handle = 0
326 encodeEntry[0] = 0;
327 encodeEntry[1] = 0;
328
329 EXPECT_EQ(stringEntryLength0, encodeEntry);
330}
331
John Wangca230822019-10-16 11:39:27 +0800332TEST(AttrTable, integerEntryEncodeTest)
333{
334 std::vector<uint8_t> integerEntry{
335 0, 0, /* attr handle */
336 3, /* attr type */
337 1, 0, /* attr name handle */
338 1, 0, 0, 0, 0, 0, 0, 0, /* lower bound */
339 10, 0, 0, 0, 0, 0, 0, 0, /* upper bound */
340 2, 0, 0, 0, /* scalar increment */
341 3, 0, 0, 0, 0, 0, 0, 0, /* defaut value */
342 };
343
344 std::vector<uint16_t> pv_hdls{2, 3};
345 std::vector<uint8_t> defs{0};
346
347 struct pldm_bios_table_attr_entry_integer_info info = {
348 1, /* name handle */
349 false, /* read only */
350 1, /* lower bound */
351 10, /* upper bound */
352 2, /* sacalar increment */
353 3 /* default value */
354 };
355 auto encodeLength = pldm_bios_table_attr_entry_integer_encode_length();
356 EXPECT_EQ(encodeLength, integerEntry.size());
357
358 std::vector<uint8_t> encodeEntry(encodeLength, 0);
359 pldm_bios_table_attr_entry_integer_encode(encodeEntry.data(),
360 encodeEntry.size(), &info);
361 // set attr handle = 0
362 encodeEntry[0] = 0;
363 encodeEntry[1] = 0;
364
365 EXPECT_EQ(integerEntry, encodeEntry);
366
367 EXPECT_DEATH(pldm_bios_table_attr_entry_integer_encode(
368 encodeEntry.data(), encodeEntry.size() - 1, &info),
369 "length <= entry_length");
370
371 auto rc = pldm_bios_table_attr_entry_integer_encode_check(
372 encodeEntry.data(), encodeEntry.size(), &info);
373 EXPECT_EQ(rc, PLDM_SUCCESS);
374 // set attr handle = 0
375 encodeEntry[0] = 0;
376 encodeEntry[1] = 0;
377
378 EXPECT_EQ(integerEntry, encodeEntry);
379
380 rc = pldm_bios_table_attr_entry_integer_encode_check(
381 encodeEntry.data(), encodeEntry.size() - 1, &info);
382 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
383
384 info.lower_bound = 100;
385 info.upper_bound = 50;
John Wang827c5de2019-11-07 18:27:27 +0800386 const char* errmsg;
387 rc = pldm_bios_table_attr_entry_integer_info_check(&info, &errmsg);
388 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
389 EXPECT_STREQ("LowerBound should not be greater than UpperBound", errmsg);
John Wangca230822019-10-16 11:39:27 +0800390 rc = pldm_bios_table_attr_entry_integer_encode_check(
391 encodeEntry.data(), encodeEntry.size(), &info);
392 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
393}
394
John Wang50218a62020-02-12 17:10:28 +0800395TEST(AttrTable, integerEntryDecodeTest)
396{
397 std::vector<uint8_t> integerEntry{
398 0, 0, /* attr handle */
399 3, /* attr type */
400 1, 0, /* attr name handle */
401 1, 0, 0, 0, 0, 0, 0, 0, /* lower bound */
402 10, 0, 0, 0, 0, 0, 0, 0, /* upper bound */
403 2, 0, 0, 0, /* scalar increment */
404 3, 0, 0, 0, 0, 0, 0, 0, /* defaut value */
405 };
406
407 uint64_t lower, upper, def;
408 uint32_t scalar;
409 auto entry = reinterpret_cast<struct pldm_bios_attr_table_entry*>(
410 integerEntry.data());
411 pldm_bios_table_attr_entry_integer_decode(entry, &lower, &upper, &scalar,
412 &def);
413 EXPECT_EQ(lower, 1);
414 EXPECT_EQ(upper, 10);
415 EXPECT_EQ(scalar, 2);
416 EXPECT_EQ(def, 3);
417}
418
John Wang02700402019-10-06 16:34:29 +0800419TEST(AttrTable, ItearatorTest)
420{
421 std::vector<uint8_t> enumEntry{
422 0, 0, /* attr handle */
423 0, /* attr type */
424 1, 0, /* attr name handle */
425 2, /* number of possible value */
426 2, 0, /* possible value handle */
427 3, 0, /* possible value handle */
428 1, /* number of default value */
429 0 /* defaut value string handle index */
430 };
431 std::vector<uint8_t> stringEntry{
432 1, 0, /* attr handle */
433 1, /* attr type */
434 12, 0, /* attr name handle */
435 1, /* string type */
436 1, 0, /* minimum length of the string in bytes */
437 100, 0, /* maximum length of the string in bytes */
438 3, 0, /* length of default string in length */
439 'a', 'b', 'c' /* default string */
440 };
John Wangca230822019-10-16 11:39:27 +0800441 std::vector<uint8_t> integerEntry{
442 0, 0, /* attr handle */
443 3, /* attr type */
444 1, 0, /* attr name handle */
445 1, 0, 0, 0, 0, 0, 0, 0, /* lower bound */
446 10, 0, 0, 0, 0, 0, 0, 0, /* upper bound */
447 2, 0, 0, 0, /* scalar increment */
448 3, 0, 0, 0, 0, 0, 0, 0, /* defaut value */
449 };
John Wang02700402019-10-06 16:34:29 +0800450
451 Table table;
John Wangca230822019-10-16 11:39:27 +0800452 buildTable(table, enumEntry, stringEntry, integerEntry, enumEntry);
John Wang02700402019-10-06 16:34:29 +0800453 auto iter = pldm_bios_table_iter_create(table.data(), table.size(),
454 PLDM_BIOS_ATTR_TABLE);
455 auto entry = pldm_bios_table_iter_attr_entry_value(iter);
456 auto rc = std::memcmp(entry, enumEntry.data(), enumEntry.size());
457 EXPECT_EQ(rc, 0);
458
459 pldm_bios_table_iter_next(iter);
460 entry = pldm_bios_table_iter_attr_entry_value(iter);
461 rc = std::memcmp(entry, stringEntry.data(), stringEntry.size());
462 EXPECT_EQ(rc, 0);
463
464 pldm_bios_table_iter_next(iter);
465 entry = pldm_bios_table_iter_attr_entry_value(iter);
John Wangca230822019-10-16 11:39:27 +0800466 rc = std::memcmp(entry, integerEntry.data(), integerEntry.size());
467 EXPECT_EQ(rc, 0);
468
469 pldm_bios_table_iter_next(iter);
470 entry = pldm_bios_table_iter_attr_entry_value(iter);
John Wang02700402019-10-06 16:34:29 +0800471 rc = std::memcmp(entry, enumEntry.data(), enumEntry.size());
472 EXPECT_EQ(rc, 0);
473
474 pldm_bios_table_iter_next(iter);
475 EXPECT_TRUE(pldm_bios_table_iter_is_end(iter));
476 pldm_bios_table_iter_free(iter);
477}
478
John Wangb0da7a02020-01-07 16:55:00 +0800479TEST(AttrTable, FindTest)
480{
481 std::vector<uint8_t> enumEntry{
482 0, 0, /* attr handle */
483 0, /* attr type */
484 1, 0, /* attr name handle */
485 2, /* number of possible value */
486 2, 0, /* possible value handle */
487 3, 0, /* possible value handle */
488 1, /* number of default value */
489 0 /* defaut value string handle index */
490 };
491 std::vector<uint8_t> stringEntry{
492 1, 0, /* attr handle */
493 1, /* attr type */
494 12, 0, /* attr name handle */
495 1, /* string type */
496 1, 0, /* minimum length of the string in bytes */
497 100, 0, /* maximum length of the string in bytes */
498 3, 0, /* length of default string in length */
499 'a', 'b', 'c' /* default string */
500 };
501 std::vector<uint8_t> integerEntry{
502 0, 0, /* attr handle */
503 3, /* attr type */
504 1, 0, /* attr name handle */
505 1, 0, 0, 0, 0, 0, 0, 0, /* lower bound */
506 10, 0, 0, 0, 0, 0, 0, 0, /* upper bound */
507 2, 0, 0, 0, /* scalar increment */
508 3, 0, 0, 0, 0, 0, 0, 0, /* defaut value */
509 };
510
511 Table table;
512 buildTable(table, enumEntry, stringEntry, integerEntry, enumEntry);
513
514 auto entry =
515 pldm_bios_table_attr_find_by_handle(table.data(), table.size(), 1);
516 EXPECT_NE(entry, nullptr);
517 auto p = reinterpret_cast<const uint8_t*>(entry);
518 EXPECT_THAT(std::vector<uint8_t>(p, p + stringEntry.size()),
519 ElementsAreArray(stringEntry));
520
521 entry = pldm_bios_table_attr_find_by_handle(table.data(), table.size(), 3);
522 EXPECT_EQ(entry, nullptr);
523}
524
525TEST(AttrValTable, HeaderDecodeTest)
526{
527 std::vector<uint8_t> enumEntry{
528 1, 0, /* attr handle */
529 0, /* attr type */
530 2, /* number of current value */
531 0, /* current value string handle index */
532 1, /* current value string handle index */
533 };
534 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
535 enumEntry.data());
536 auto attrHandle =
537 pldm_bios_table_attr_value_entry_decode_attribute_handle(entry);
538 EXPECT_EQ(attrHandle, 1);
539 auto attrType =
540 pldm_bios_table_attr_value_entry_decode_attribute_type(entry);
541 EXPECT_EQ(attrType, 0);
542}
543
John Wang3ad21752019-10-06 16:42:21 +0800544TEST(AttrValTable, EnumEntryEncodeTest)
545{
546 std::vector<uint8_t> enumEntry{
547 0, 0, /* attr handle */
548 0, /* attr type */
549 2, /* number of current value */
550 0, /* current value string handle index */
551 1, /* current value string handle index */
552 };
553
554 auto length = pldm_bios_table_attr_value_entry_encode_enum_length(2);
555 EXPECT_EQ(length, enumEntry.size());
556 std::vector<uint8_t> encodeEntry(length, 0);
557 uint8_t handles[] = {0, 1};
558 pldm_bios_table_attr_value_entry_encode_enum(
559 encodeEntry.data(), encodeEntry.size(), 0, 0, 2, handles);
560 EXPECT_EQ(encodeEntry, enumEntry);
561
562 EXPECT_DEATH(
563 pldm_bios_table_attr_value_entry_encode_enum(
564 encodeEntry.data(), encodeEntry.size() - 1, 0, 0, 2, handles),
565 "length <= entry_length");
566
567 auto rc = pldm_bios_table_attr_value_entry_encode_enum_check(
568 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_ENUMERATION, 2,
569 handles);
570 EXPECT_EQ(rc, PLDM_SUCCESS);
571 EXPECT_EQ(encodeEntry, enumEntry);
572 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
573 enumEntry.data());
574 entry->attr_type = PLDM_BIOS_ENUMERATION_READ_ONLY;
575 rc = pldm_bios_table_attr_value_entry_encode_enum_check(
576 encodeEntry.data(), encodeEntry.size(), 0,
577 PLDM_BIOS_ENUMERATION_READ_ONLY, 2, handles);
578 EXPECT_EQ(rc, PLDM_SUCCESS);
579 EXPECT_EQ(encodeEntry, enumEntry);
580 rc = pldm_bios_table_attr_value_entry_encode_enum_check(
581 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_PASSWORD, 2,
582 handles);
583 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
584 rc = pldm_bios_table_attr_value_entry_encode_enum_check(
585 encodeEntry.data(), encodeEntry.size() - 1, 0, PLDM_BIOS_ENUMERATION, 2,
586 handles);
587 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
588}
589
John Wang49484a12019-12-02 14:21:53 +0800590TEST(AttrValTable, EnumEntryDecodeTest)
591{
592 std::vector<uint8_t> enumEntry{
593 0, 0, /* attr handle */
594 0, /* attr type */
595 2, /* number of current value */
596 0, /* current value string handle index */
597 1, /* current value string handle index */
598 };
599
600 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
601 enumEntry.data());
602 auto number = pldm_bios_table_attr_value_entry_enum_decode_number(entry);
603 EXPECT_EQ(2, number);
John Wangb0da7a02020-01-07 16:55:00 +0800604
605 std::vector<uint8_t> handles(2, 0);
606 auto rc = pldm_bios_table_attr_value_entry_enum_decode_handles(
607 entry, handles.data(), handles.size());
608 EXPECT_EQ(rc, 2);
609 EXPECT_EQ(handles[0], 0);
610 EXPECT_EQ(handles[1], 1);
John Wang49484a12019-12-02 14:21:53 +0800611}
612
John Wang3ad21752019-10-06 16:42:21 +0800613TEST(AttrValTable, stringEntryEncodeTest)
614{
615 std::vector<uint8_t> stringEntry{
616 0, 0, /* attr handle */
617 1, /* attr type */
618 3, 0, /* current string length */
619 'a', 'b', 'c', /* defaut value string handle index */
620 };
621
622 auto length = pldm_bios_table_attr_value_entry_encode_string_length(3);
623 EXPECT_EQ(length, stringEntry.size());
624 std::vector<uint8_t> encodeEntry(length, 0);
625 pldm_bios_table_attr_value_entry_encode_string(
626 encodeEntry.data(), encodeEntry.size(), 0, 1, 3, "abc");
627 EXPECT_EQ(encodeEntry, stringEntry);
628
629 EXPECT_DEATH(
630 pldm_bios_table_attr_value_entry_encode_string(
631 encodeEntry.data(), encodeEntry.size() - 1, 0, 1, 3, "abc"),
632 "length <= entry_length");
633
634 auto rc = pldm_bios_table_attr_value_entry_encode_string_check(
635 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_STRING, 3, "abc");
636 EXPECT_EQ(rc, PLDM_SUCCESS);
637 EXPECT_EQ(encodeEntry, stringEntry);
638 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
639 stringEntry.data());
640 entry->attr_type = PLDM_BIOS_STRING_READ_ONLY;
641 rc = pldm_bios_table_attr_value_entry_encode_string_check(
642 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_STRING_READ_ONLY,
643 3, "abc");
644 EXPECT_EQ(rc, PLDM_SUCCESS);
645 EXPECT_EQ(encodeEntry, stringEntry);
646 rc = pldm_bios_table_attr_value_entry_encode_string_check(
647 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_PASSWORD, 3,
648 "abc");
649 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
650 rc = pldm_bios_table_attr_value_entry_encode_string_check(
651 encodeEntry.data(), encodeEntry.size() - 1, 0, PLDM_BIOS_STRING, 3,
652 "abc");
653 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
654}
655
John Wang49484a12019-12-02 14:21:53 +0800656TEST(AttrValTable, StringEntryDecodeTest)
657{
658 std::vector<uint8_t> stringEntry{
659 0, 0, /* attr handle */
660 1, /* attr type */
661 3, 0, /* current string length */
662 'a', 'b', 'c', /* defaut value string handle index */
663 };
664
665 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
666 stringEntry.data());
667 auto length = pldm_bios_table_attr_value_entry_string_decode_length(entry);
668 EXPECT_EQ(3, length);
John Wang3342adb2019-11-29 16:03:58 +0800669
670 auto handle = pldm_bios_table_attr_value_entry_decode_handle(entry);
671 EXPECT_EQ(0, handle);
672
John Wang8e877e02020-02-03 16:06:55 +0800673 auto entryLength = pldm_bios_table_attr_value_entry_length(entry);
674 EXPECT_EQ(stringEntry.size(), entryLength);
John Wangb0da7a02020-01-07 16:55:00 +0800675
676 variable_field currentString{};
677 pldm_bios_table_attr_value_entry_string_decode_string(entry,
678 &currentString);
679 EXPECT_THAT(std::vector<uint8_t>(currentString.ptr,
680 currentString.ptr + currentString.length),
681 ElementsAreArray(std::vector<uint8_t>{'a', 'b', 'c'}));
John Wang49484a12019-12-02 14:21:53 +0800682}
683
John Wangca230822019-10-16 11:39:27 +0800684TEST(AttrValTable, integerEntryEncodeTest)
685{
686 std::vector<uint8_t> integerEntry{
687 0, 0, /* attr handle */
688 3, /* attr type */
689 10, 0, 0, 0, 0, 0, 0, 0, /* current value */
690 };
691
692 auto length = pldm_bios_table_attr_value_entry_encode_integer_length();
693 EXPECT_EQ(length, integerEntry.size());
694 std::vector<uint8_t> encodeEntry(length, 0);
695 pldm_bios_table_attr_value_entry_encode_integer(
696 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_INTEGER, 10);
697 EXPECT_EQ(encodeEntry, integerEntry);
698
699 EXPECT_DEATH(pldm_bios_table_attr_value_entry_encode_integer(
700 encodeEntry.data(), encodeEntry.size() - 1, 0,
701 PLDM_BIOS_INTEGER, 10),
702 "length <= entry_length");
703
704 auto rc = pldm_bios_table_attr_value_entry_encode_integer_check(
705 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_INTEGER, 10);
706 EXPECT_EQ(rc, PLDM_SUCCESS);
707 EXPECT_EQ(encodeEntry, integerEntry);
708 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
709 integerEntry.data());
710 entry->attr_type = PLDM_BIOS_INTEGER_READ_ONLY;
711 rc = pldm_bios_table_attr_value_entry_encode_integer_check(
712 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_INTEGER_READ_ONLY,
713 10);
714 EXPECT_EQ(rc, PLDM_SUCCESS);
715 EXPECT_EQ(encodeEntry, integerEntry);
716
717 rc = pldm_bios_table_attr_value_entry_encode_integer_check(
718 encodeEntry.data(), encodeEntry.size(), 0, PLDM_BIOS_PASSWORD, 10);
719 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
720 rc = pldm_bios_table_attr_value_entry_encode_integer_check(
721 encodeEntry.data(), encodeEntry.size() - 1, 0,
722 PLDM_BIOS_INTEGER_READ_ONLY, 10);
723 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
724}
725
John Wangb0da7a02020-01-07 16:55:00 +0800726TEST(AttrValTable, integerEntryDecodeTest)
727{
728 std::vector<uint8_t> integerEntry{
729 0, 0, /* attr handle */
730 3, /* attr type */
731 10, 0, 0, 0, 0, 0, 0, 0, /* current value */
732 };
733
734 auto entry = reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
735 integerEntry.data());
736 auto cv = pldm_bios_table_attr_value_entry_integer_decode_cv(entry);
737 EXPECT_EQ(cv, 10);
738}
739
John Wang49484a12019-12-02 14:21:53 +0800740TEST(AttrValTable, IteratorTest)
741{
742 std::vector<uint8_t> enumEntry{
743 0, 0, /* attr handle */
744 0, /* attr type */
745 2, /* number of current value */
746 0, /* current value string handle index */
747 1, /* current value string handle index */
748 };
749 std::vector<uint8_t> stringEntry{
750 0, 0, /* attr handle */
751 1, /* attr type */
752 3, 0, /* current string length */
753 'a', 'b', 'c', /* defaut value string handle index */
754 };
755 std::vector<uint8_t> integerEntry{
756 0, 0, /* attr handle */
757 3, /* attr type */
758 10, 0, 0, 0, 0, 0, 0, 0, /* current value */
759 };
760
761 Table table;
762 buildTable(table, enumEntry, stringEntry, integerEntry, enumEntry);
763
764 auto iter = pldm_bios_table_iter_create(table.data(), table.size(),
765 PLDM_BIOS_ATTR_VAL_TABLE);
766 auto entry = pldm_bios_table_iter_attr_value_entry_value(iter);
767
768 auto p = reinterpret_cast<const uint8_t*>(entry);
769 EXPECT_THAT(std::vector<uint8_t>(p, p + enumEntry.size()),
770 ElementsAreArray(enumEntry));
771
772 pldm_bios_table_iter_next(iter);
773 entry = pldm_bios_table_iter_attr_value_entry_value(iter);
774 p = reinterpret_cast<const uint8_t*>(entry);
775 EXPECT_THAT(std::vector<uint8_t>(p, p + stringEntry.size()),
776 ElementsAreArray(stringEntry));
777
778 pldm_bios_table_iter_next(iter);
779 entry = pldm_bios_table_iter_attr_value_entry_value(iter);
780 p = reinterpret_cast<const uint8_t*>(entry);
781 EXPECT_THAT(std::vector<uint8_t>(p, p + integerEntry.size()),
782 ElementsAreArray(integerEntry));
783
784 pldm_bios_table_iter_next(iter);
785 entry = pldm_bios_table_iter_attr_value_entry_value(iter);
786 p = reinterpret_cast<const uint8_t*>(entry);
787 EXPECT_THAT(std::vector<uint8_t>(p, p + enumEntry.size()),
788 ElementsAreArray(enumEntry));
789
790 pldm_bios_table_iter_next(iter);
791 EXPECT_TRUE(pldm_bios_table_iter_is_end(iter));
792
793 pldm_bios_table_iter_free(iter);
794}
795
John Wang3342adb2019-11-29 16:03:58 +0800796TEST(AttrValTable, FindTest)
797{
798 std::vector<uint8_t> enumEntry{
799 0, 0, /* attr handle */
800 0, /* attr type */
801 2, /* number of current value */
802 0, /* current value string handle index */
803 1, /* current value string handle index */
804 };
805 std::vector<uint8_t> stringEntry{
806 1, 0, /* attr handle */
807 1, /* attr type */
808 3, 0, /* current string length */
809 'a', 'b', 'c', /* defaut value string handle index */
810 };
811 std::vector<uint8_t> integerEntry{
812 2, 0, /* attr handle */
813 3, /* attr type */
814 10, 0, 0, 0, 0, 0, 0, 0, /* current value */
815 };
816
817 Table table;
818 buildTable(table, enumEntry, stringEntry, integerEntry);
819
820 auto entry = pldm_bios_table_attr_value_find_by_handle(table.data(),
821 table.size(), 1);
822 EXPECT_NE(entry, nullptr);
823 auto p = reinterpret_cast<const uint8_t*>(entry);
824 EXPECT_THAT(std::vector<uint8_t>(p, p + stringEntry.size()),
825 ElementsAreArray(stringEntry));
826
827 entry = pldm_bios_table_attr_value_find_by_handle(table.data(),
828 table.size(), 3);
829 EXPECT_EQ(entry, nullptr);
830
831 auto firstEntry =
832 reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(table.data());
833 firstEntry->attr_type = PLDM_BIOS_PASSWORD;
834 EXPECT_DEATH(pldm_bios_table_attr_value_find_by_handle(table.data(),
835 table.size(), 1),
836 "entry_length != NULL");
837}
838
John Wang871c9272019-12-09 18:02:15 +0800839TEST(AttrValTable, CopyAndUpdateTest)
840{
841 std::vector<uint8_t> enumEntry{
842 0, 0, /* attr handle */
843 0, /* attr type */
844 2, /* number of current value */
845 0, /* current value string handle index */
846 1, /* current value string handle index */
847 };
848 std::vector<uint8_t> stringEntry{
849 1, 0, /* attr handle */
850 1, /* attr type */
851 3, 0, /* current string length */
852 'a', 'b', 'c', /* defaut value string handle index */
853 };
854 std::vector<uint8_t> integerEntry{
855 2, 0, /* attr handle */
856 3, /* attr type */
857 10, 0, 0, 0, 0, 0, 0, 0, /* current value */
858 };
859
860 Table srcTable;
861 buildTable(srcTable, enumEntry, stringEntry, integerEntry);
862
863 std::vector<uint8_t> stringEntry1{
864 1, 0, /* attr handle */
865 1, /* attr type */
866 3, 0, /* current string length */
867 'd', 'e', 'f', /* defaut value string handle index */
868 };
869
870 Table expectTable;
871 buildTable(expectTable, enumEntry, stringEntry1, integerEntry);
872 Table destTable(expectTable.size() + 10);
873 auto destLength = destTable.size();
874 auto rc = pldm_bios_table_attr_value_copy_and_update(
875 srcTable.data(), srcTable.size(), destTable.data(), &destLength,
876 stringEntry1.data(), stringEntry1.size());
877
878 EXPECT_EQ(rc, PLDM_SUCCESS);
879 EXPECT_EQ(destLength, expectTable.size());
880 destTable.resize(destLength);
881 EXPECT_THAT(destTable, ElementsAreArray(expectTable));
882
883 std::vector<uint8_t> stringEntry2{
884 1, 0, /* attr handle */
885 1, /* attr type */
886 5, 0, /* current string length */
887 'd', 'e', 'f', 'a', 'b', /* defaut value string handle index */
888 };
889 expectTable.resize(0);
890 buildTable(expectTable, enumEntry, stringEntry2, integerEntry);
891 destTable.resize(expectTable.size() + 10);
892 destLength = destTable.size();
893 rc = pldm_bios_table_attr_value_copy_and_update(
894 srcTable.data(), srcTable.size(), destTable.data(), &destLength,
895 stringEntry2.data(), stringEntry2.size());
896 EXPECT_EQ(rc, PLDM_SUCCESS);
897 EXPECT_EQ(destLength, expectTable.size());
898 destTable.resize(destLength);
899 EXPECT_THAT(destTable, ElementsAreArray(expectTable));
900
901 std::vector<uint8_t> stringEntry3{
902 1, 0, /* attr handle */
903 1, /* attr type */
904 1, 0, /* current string length */
905 'd', /* defaut value string handle index */
906 };
907 expectTable.resize(0);
908 buildTable(expectTable, enumEntry, stringEntry3, integerEntry);
909 destTable.resize(expectTable.size() + 10);
910 destLength = destTable.size();
911 rc = pldm_bios_table_attr_value_copy_and_update(
912 srcTable.data(), srcTable.size(), destTable.data(), &destLength,
913 stringEntry3.data(), stringEntry3.size());
914 EXPECT_EQ(rc, PLDM_SUCCESS);
915 EXPECT_EQ(destLength, expectTable.size());
916 destTable.resize(destLength);
917 EXPECT_THAT(destTable, ElementsAreArray(expectTable));
918
John Wange176a652020-02-14 14:57:50 +0800919 stringEntry3[2] = PLDM_BIOS_INTEGER; // set attribute type to integer
920 rc = pldm_bios_table_attr_value_copy_and_update(
921 srcTable.data(), srcTable.size(), destTable.data(), &destLength,
922 stringEntry3.data(), stringEntry3.size());
923 EXPECT_EQ(rc, PLDM_ERROR_INVALID_DATA);
924 stringEntry3[2] = PLDM_BIOS_STRING; // set attribute type to string
925
John Wang871c9272019-12-09 18:02:15 +0800926 destTable.resize(expectTable.size() - 1);
927 destLength = destTable.size();
928 rc = pldm_bios_table_attr_value_copy_and_update(
929 srcTable.data(), srcTable.size(), destTable.data(), &destLength,
930 stringEntry3.data(), stringEntry3.size());
931 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
932}
933
John Wangdd9a6282019-10-11 18:52:46 +0800934TEST(StringTable, EntryEncodeTest)
935{
936 std::vector<uint8_t> stringEntry{
937 0, 0, /* string handle*/
938 7, 0, /* string length */
939 'A', 'l', 'l', 'o', 'w', 'e', 'd', /* string */
940 };
941
942 const char* str = "Allowed";
943 auto str_length = std::strlen(str);
944 auto encodeLength = pldm_bios_table_string_entry_encode_length(str_length);
945 EXPECT_EQ(encodeLength, stringEntry.size());
946
947 std::vector<uint8_t> encodeEntry(encodeLength, 0);
948 pldm_bios_table_string_entry_encode(encodeEntry.data(), encodeEntry.size(),
949 str, str_length);
950 // set string handle = 0
951 encodeEntry[0] = 0;
952 encodeEntry[1] = 0;
953
954 EXPECT_EQ(stringEntry, encodeEntry);
955
956 EXPECT_DEATH(pldm_bios_table_string_entry_encode(encodeEntry.data(),
957 encodeEntry.size() - 1,
958 str, str_length),
959 "length <= entry_length");
960 auto rc = pldm_bios_table_string_entry_encode_check(
961 encodeEntry.data(), encodeEntry.size() - 1, str, str_length);
962 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
963}
964
965TEST(StringTable, EntryDecodeTest)
966{
967 std::vector<uint8_t> stringEntry{
968 4, 0, /* string handle*/
969 7, 0, /* string length */
970 'A', 'l', 'l', 'o', 'w', 'e', 'd', /* string */
971 };
972 auto entry = reinterpret_cast<struct pldm_bios_string_table_entry*>(
973 stringEntry.data());
974 auto handle = pldm_bios_table_string_entry_decode_handle(entry);
975 EXPECT_EQ(handle, 4);
976 auto strLength = pldm_bios_table_string_entry_decode_string_length(entry);
977 EXPECT_EQ(strLength, 7);
978
979 std::vector<char> buffer(strLength + 1, 0);
980 auto decodedLength = pldm_bios_table_string_entry_decode_string(
981 entry, buffer.data(), buffer.size());
982 EXPECT_EQ(decodedLength, strLength);
983 EXPECT_EQ(std::strcmp("Allowed", buffer.data()), 0);
John Wang88a349c2020-01-20 14:19:49 +0800984 decodedLength = pldm_bios_table_string_entry_decode_string(
985 entry, buffer.data(), 2 + 1 /* sizeof '\0'*/);
John Wangdd9a6282019-10-11 18:52:46 +0800986 EXPECT_EQ(decodedLength, 2);
987 EXPECT_EQ(std::strcmp("Al", buffer.data()), 0);
988
989 auto rc = pldm_bios_table_string_entry_decode_string_check(
990 entry, buffer.data(), buffer.size());
991 EXPECT_EQ(rc, PLDM_SUCCESS);
992 EXPECT_EQ(std::strcmp("Allowed", buffer.data()), 0);
993
994 rc = pldm_bios_table_string_entry_decode_string_check(entry, buffer.data(),
995 buffer.size() - 1);
996 EXPECT_EQ(rc, PLDM_ERROR_INVALID_LENGTH);
997}
998
999TEST(StringTable, IteratorTest)
1000{
1001 std::vector<uint8_t> stringHello{
1002 0, 0, /* string handle*/
1003 5, 0, /* string length */
1004 'H', 'e', 'l', 'l', 'o', /* string */
1005 };
1006 std::vector<uint8_t> stringWorld{
1007 1, 0, /* string handle*/
1008 6, 0, /* string length */
1009 'W', 'o', 'r', 'l', 'd', '!', /* string */
1010 };
1011
1012 Table table;
1013 buildTable(table, stringHello, stringWorld);
1014
1015 auto iter = pldm_bios_table_iter_create(table.data(), table.size(),
1016 PLDM_BIOS_STRING_TABLE);
1017 auto entry = pldm_bios_table_iter_string_entry_value(iter);
1018 auto rc = std::memcmp(entry, stringHello.data(), stringHello.size());
1019 EXPECT_EQ(rc, 0);
1020 pldm_bios_table_iter_next(iter);
1021 entry = pldm_bios_table_iter_string_entry_value(iter);
1022 rc = std::memcmp(entry, stringWorld.data(), stringWorld.size());
1023 EXPECT_EQ(rc, 0);
1024 pldm_bios_table_iter_next(iter);
1025 EXPECT_TRUE(pldm_bios_table_iter_is_end(iter));
1026 pldm_bios_table_iter_free(iter);
1027}
1028
1029TEST(StringTable, FindTest)
1030{
1031 std::vector<uint8_t> stringHello{
1032 1, 0, /* string handle*/
1033 5, 0, /* string length */
1034 'H', 'e', 'l', 'l', 'o', /* string */
1035 };
1036 std::vector<uint8_t> stringWorld{
1037 2, 0, /* string handle*/
1038 6, 0, /* string length */
1039 'W', 'o', 'r', 'l', 'd', '!', /* string */
1040 };
1041 std::vector<uint8_t> stringHi{
1042 3, 0, /* string handle*/
1043 2, 0, /* string length */
1044 'H', 'i', /* string */
1045 };
1046
1047 Table table;
1048 buildTable(table, stringHello, stringWorld, stringHi);
1049
1050 auto entry = pldm_bios_table_string_find_by_string(table.data(),
1051 table.size(), "World!");
1052 EXPECT_NE(entry, nullptr);
1053 auto handle = pldm_bios_table_string_entry_decode_handle(entry);
1054 EXPECT_EQ(handle, 2);
1055
1056 entry = pldm_bios_table_string_find_by_string(table.data(), table.size(),
1057 "Worl");
1058 EXPECT_EQ(entry, nullptr);
1059
1060 entry =
1061 pldm_bios_table_string_find_by_handle(table.data(), table.size(), 3);
1062 EXPECT_NE(entry, nullptr);
1063 auto str_length = pldm_bios_table_string_entry_decode_string_length(entry);
1064 EXPECT_EQ(str_length, 2);
1065 std::vector<char> strBuf(str_length + 1, 0);
1066 auto rc = pldm_bios_table_string_entry_decode_string_check(
1067 entry, strBuf.data(), strBuf.size());
1068 EXPECT_EQ(rc, PLDM_SUCCESS);
1069 EXPECT_EQ(std::strcmp("Hi", strBuf.data()), 0);
1070
1071 entry =
1072 pldm_bios_table_string_find_by_handle(table.data(), table.size(), 4);
1073 EXPECT_EQ(entry, nullptr);
1074}
1075
John Wang02700402019-10-06 16:34:29 +08001076TEST(Itearator, DeathTest)
1077{
1078
1079 Table table(256, 0);
1080
1081 /* first entry */
1082 auto attr_entry =
1083 reinterpret_cast<struct pldm_bios_attr_table_entry*>(table.data());
1084 auto iter = pldm_bios_table_iter_create(table.data(), table.size(),
1085 PLDM_BIOS_ATTR_TABLE);
1086 attr_entry->attr_type = PLDM_BIOS_PASSWORD;
1087 EXPECT_DEATH(pldm_bios_table_iter_next(iter), "attr_table_entry != NULL");
John Wang02700402019-10-06 16:34:29 +08001088 pldm_bios_table_iter_free(iter);
1089}
John Wang79c37f12019-10-31 15:46:31 +08001090
1091TEST(PadAndChecksum, PadAndChecksum)
1092{
1093 EXPECT_EQ(4, pldm_bios_table_pad_checksum_size(0));
1094 EXPECT_EQ(7, pldm_bios_table_pad_checksum_size(1));
1095 EXPECT_EQ(6, pldm_bios_table_pad_checksum_size(2));
1096 EXPECT_EQ(5, pldm_bios_table_pad_checksum_size(3));
1097 EXPECT_EQ(4, pldm_bios_table_pad_checksum_size(4));
1098
1099 // The table is borrowed from
1100 // https://github.com/openbmc/pldm/commit/69d3e7fb2d9935773f4fbf44326c33f3fc0a3c38
1101 // refer to the commit message
1102 Table attrValTable = {0x09, 0x00, 0x01, 0x02, 0x00, 0x65, 0x66};
1103 auto sizeWithoutPad = attrValTable.size();
1104 attrValTable.resize(sizeWithoutPad +
1105 pldm_bios_table_pad_checksum_size(sizeWithoutPad));
1106 pldm_bios_table_append_pad_checksum(attrValTable.data(),
1107 attrValTable.size(), sizeWithoutPad);
1108 Table expectedTable = {0x09, 0x00, 0x01, 0x02, 0x00, 0x65,
1109 0x66, 0x00, 0x6d, 0x81, 0x4a, 0xb6};
1110 EXPECT_EQ(attrValTable, expectedTable);
1111}