test/libpldmresponder_bios_test.cpp - openbmc/pldm - Gitiles

 #include "libpldmresponder/bios.hpp"
 #include "libpldmresponder/bios_parser.hpp"
 #include "libpldmresponder/bios_table.hpp"

 #include <string.h>

 #include <array>
 #include <ctime>
 #include <filesystem>

 #include "libpldm/base.h"
 #include "libpldm/bios.h"

 #include <gtest/gtest.h>

 using namespace pldm;
 using namespace pldm::responder;
 using namespace pldm::responder::bios;
 using namespace pldm::responder::utils;
 using namespace bios_parser;
 using namespace bios_parser::bios_enum;

 TEST(epochToBCDTime, testTime)
 {
     struct tm time
     {
     };
     time.tm_year = 119;
     time.tm_mon = 3;
     time.tm_mday = 13;
     time.tm_hour = 5;
     time.tm_min = 18;
     time.tm_sec = 13;
     time.tm_isdst = -1;

     time_t epochTime = mktime(&time);
     uint8_t seconds = 0;
     uint8_t minutes = 0;
     uint8_t hours = 0;
     uint8_t day = 0;
     uint8_t month = 0;
     uint16_t year = 0;

     epochToBCDTime(epochTime, seconds, minutes, hours, day, month, year);

     ASSERT_EQ(0x13, seconds);
     ASSERT_EQ(0x18, minutes);
     ASSERT_EQ(0x5, hours);
     ASSERT_EQ(0x13, day);
     ASSERT_EQ(0x4, month);
     ASSERT_EQ(0x2019, year);
 }

 TEST(GetBIOSStrings, allScenarios)
 {
     using namespace bios_parser;
     // All the BIOS Strings in the BIOS JSON config files.
     Strings vec{"HMCManagedState",  "On",           "Off",
                 "FWBootSide",       "Perm",         "Temp",
                 "InbandCodeUpdate", "Allowed",      "NotAllowed",
                 "CodeUpdatePolicy", "Concurrent",   "Disruptive",
                 "str_example1",     "str_example2", "str_example3"};

     Strings nullVec{};

     // Invalid directory
     auto strings = bios_parser::getStrings("./bios_json");
     ASSERT_EQ(strings == nullVec, true);

     strings = bios_parser::getStrings("./bios_jsons");
     std::sort(strings.begin(), strings.end());
     std::sort(vec.begin(), vec.end());
     ASSERT_EQ(strings == vec, true);
 }

 TEST(getAttrValue, allScenarios)
 {
     using namespace bios_parser::bios_enum;
     // All the BIOS Strings in the BIOS JSON config files.
     AttrValuesMap valueMap{
         {"HMCManagedState", {false, {"On", "Off"}, {"On"}}},
         {"FWBootSide", {false, {"Perm", "Temp"}, {"Perm"}}},
         {"InbandCodeUpdate", {false, {"Allowed", "NotAllowed"}, {"Allowed"}}},
         {"CodeUpdatePolicy",
          {false, {"Concurrent", "Disruptive"}, {"Concurrent"}}}};

     auto rc = setupValueLookup("./bios_jsons");
     ASSERT_EQ(rc, 0);

     auto values = getValues();
     ASSERT_EQ(valueMap == values, true);

     CurrentValues cv{"Concurrent"};
     auto value = getAttrValue("CodeUpdatePolicy");
     ASSERT_EQ(value == cv, true);

     // Invalid attribute name
     ASSERT_THROW(getAttrValue("CodeUpdatePolic"), std::out_of_range);
 }

 namespace fs = std::filesystem;
 class TestAllBIOSTables : public ::testing::Test
 {
   public:
     static void SetUpTestCase() // will execute once at the begining of all
                                 // TestAllBIOSTables objects
     {
         char tmpdir[] = "/tmp/allBiosTables.XXXXXX";
         biosPath = fs::path(mkdtemp(tmpdir));
     }

     static void TearDownTestCase() // will be executed once at th eend of all
                                    // TestAllBIOSTables objects
     {
         fs::remove_all(biosPath);
     }

     static fs::path biosPath;
 };

 fs::path TestAllBIOSTables::biosPath;

 TEST_F(TestAllBIOSTables, GetBIOSTableTestBadRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
         requestPayload{};
     auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
     struct pldm_get_bios_table_req* req =
         (struct pldm_get_bios_table_req*)request->payload;
     req->transfer_handle = 9;
     req->transfer_op_flag = PLDM_GET_FIRSTPART;
     req->table_type = 0xFF;

     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

     auto response = internal::buildBIOSTables(request, requestPayloadLength,
                                               "./bios_jsons", biosPath.c_str());
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

     struct pldm_get_bios_table_resp* resp =
         reinterpret_cast<struct pldm_get_bios_table_resp*>(
             responsePtr->payload);

     ASSERT_EQ(PLDM_INVALID_BIOS_TABLE_TYPE, resp->completion_code);
 }

 TEST_F(TestAllBIOSTables, buildBIOSTablesTestBadRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
         requestPayload{};
     auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
     struct pldm_get_bios_table_req* req =
         (struct pldm_get_bios_table_req*)request->payload;
     req->transfer_handle = 9;
     req->transfer_op_flag = PLDM_GET_FIRSTPART;
     req->table_type = PLDM_BIOS_ATTR_VAL_TABLE;

     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

     auto response = internal::buildBIOSTables(request, requestPayloadLength,
                                               "./bios_jsons", biosPath.c_str());
     auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     struct pldm_get_bios_table_resp* resp =
         reinterpret_cast<struct pldm_get_bios_table_resp*>(
             responsePtr->payload);
     ASSERT_EQ(PLDM_BIOS_TABLE_UNAVAILABLE, resp->completion_code);

     req->table_type = PLDM_BIOS_ATTR_TABLE;
     response = internal::buildBIOSTables(request, requestPayloadLength,
                                          "./bios_jsons", biosPath.c_str());
     responsePtr = reinterpret_cast<pldm_msg*>(response.data());
     resp = reinterpret_cast<struct pldm_get_bios_table_resp*>(
         responsePtr->payload);
     ASSERT_EQ(PLDM_BIOS_TABLE_UNAVAILABLE, resp->completion_code);
 }

 TEST_F(TestAllBIOSTables, GetBIOSStringTableTestGoodRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
         requestPayload{};
     auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
     struct pldm_get_bios_table_req* req =
         (struct pldm_get_bios_table_req*)request->payload;
     req->transfer_handle = 9;
     req->transfer_op_flag = PLDM_GET_FIRSTPART;
     req->table_type = PLDM_BIOS_STRING_TABLE;

     Strings biosStrings = getStrings("./bios_jsons");
     std::sort(biosStrings.begin(), biosStrings.end());
     biosStrings.erase(std::unique(biosStrings.begin(), biosStrings.end()),
                       biosStrings.end());

     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
     uint8_t times = 0;
     while (times < 2)
     { // first time fresh table second time existing table
         auto response = internal::buildBIOSTables(
             request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
         auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

         struct pldm_get_bios_table_resp* resp =
             reinterpret_cast<struct pldm_get_bios_table_resp*>(
                 responsePtr->payload);

         ASSERT_EQ(0, resp->completion_code);
         ASSERT_EQ(0, resp->next_transfer_handle);
         ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

         uint16_t strLen = 0;
         uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);

         for (auto elem : biosStrings)
         {
             struct pldm_bios_string_table_entry* ptr =
                 reinterpret_cast<struct pldm_bios_string_table_entry*>(
                     tableData);
             strLen = ptr->string_length;
             ASSERT_EQ(strLen, elem.size());
             ASSERT_EQ(0, memcmp(elem.c_str(), ptr->name, strLen));
             tableData += (sizeof(pldm_bios_string_table_entry) - 1) + strLen;

         } // end for
         times++;
     }
 }

 TEST_F(TestAllBIOSTables, getBIOSAttributeTableTestGoodRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
         requestPayload{};
     auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
     struct pldm_get_bios_table_req* req =
         (struct pldm_get_bios_table_req*)request->payload;
     req->transfer_handle = 9;
     req->transfer_op_flag = PLDM_GET_FIRSTPART;
     req->table_type = PLDM_BIOS_ATTR_TABLE;

     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

     uint8_t times = 0;
     while (times < 2)
     { // first time fresh table second time existing table
         auto response = internal::buildBIOSTables(
             request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
         auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

         struct pldm_get_bios_table_resp* resp =
             reinterpret_cast<struct pldm_get_bios_table_resp*>(
                 responsePtr->payload);

         ASSERT_EQ(0, resp->completion_code);
         ASSERT_EQ(0, resp->next_transfer_handle);
         ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

         uint32_t attrTableLen =
             response.size() - sizeof(pldm_msg_hdr) -
             (sizeof(resp->completion_code) +
              sizeof(resp->next_transfer_handle) + sizeof(resp->transfer_flag));
         uint32_t traversed = 0;
         uint16_t attrHdl = 0;
         uint16_t stringHdl = 0;
         uint8_t attrType = 0;
         uint8_t numPosVals = 0;
         uint8_t numDefVals = 0;
         uint8_t defIndex = 0;

         uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);
         while (1)
         {
             struct pldm_bios_attr_table_entry* ptr =
                 reinterpret_cast<struct pldm_bios_attr_table_entry*>(tableData);
             attrHdl = ptr->attr_handle;
             attrType = ptr->attr_type;
             EXPECT_EQ(0, attrHdl);
             EXPECT_EQ(PLDM_BIOS_ENUMERATION, attrType);
             stringHdl = ptr->string_handle;
             EXPECT_EQ(stringHdl, 1);
             tableData += sizeof(attrHdl) + sizeof(attrType) + sizeof(stringHdl);
             numPosVals = *tableData;
             EXPECT_EQ(numPosVals, 2);
             traversed += sizeof(attrHdl) + sizeof(attrType) + sizeof(stringHdl);
             traversed += sizeof(numPosVals);
             PossibleValuesByHandle possiVals;
             tableData++;
             uint16_t* temp = reinterpret_cast<uint16_t*>(tableData);
             uint32_t i = 0;
             while (i < numPosVals)
             {
                 uint16_t val = *temp;
                 possiVals.push_back(val);
                 temp++;
                 i++;
             }
             EXPECT_EQ(possiVals.size(), 2);
             tableData += numPosVals * sizeof(stringHdl);
             traversed += numPosVals * sizeof(stringHdl);
             numDefVals = *tableData;
             EXPECT_EQ(numDefVals, 1);
             tableData += numDefVals * sizeof(defIndex);
             traversed += numDefVals + sizeof(numDefVals);

             break; // test for first row only

             if ((attrTableLen - traversed) < 8)
             {
                 // reached pad
                 break;
             }

         } // end while
         times++;
     }

 } // end TEST

 TEST_F(TestAllBIOSTables, getBIOSAttributeValueTableTestGoodRequest)
 {
     std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
         requestPayload{};
     auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
     struct pldm_get_bios_table_req* req =
         (struct pldm_get_bios_table_req*)request->payload;
     req->transfer_handle = 9;
     req->transfer_op_flag = PLDM_GET_FIRSTPART;
     req->table_type = PLDM_BIOS_ATTR_VAL_TABLE;

     std::string attrName("CodeUpdatePolicy");
     CurrentValues currVals = getAttrValue(attrName);

     size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

     uint8_t times = 0;
     while (times < 2)
     { // first time frest table second time existing table
         auto response = internal::buildBIOSTables(
             request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
         auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

         struct pldm_get_bios_table_resp* resp =
             reinterpret_cast<struct pldm_get_bios_table_resp*>(
                 responsePtr->payload);

         ASSERT_EQ(0, resp->completion_code);
         ASSERT_EQ(0, resp->next_transfer_handle);
         ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

         uint32_t attrValTableLen =
             response.size() - sizeof(pldm_msg_hdr) -
             (sizeof(resp->completion_code) +
              sizeof(resp->next_transfer_handle) + sizeof(resp->transfer_flag));
         uint32_t traversed = 0;
         uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);

         uint16_t attrHdl;
         uint8_t attrType;
         uint8_t numCurrVals;
         uint8_t currValStrIndex;

         while (1)
         {
             struct pldm_bios_attr_val_table_entry* ptr =
                 reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
                     tableData);
             attrHdl = ptr->attr_handle;
             attrType = ptr->attr_type;
             EXPECT_EQ(0, attrHdl);
             EXPECT_EQ(PLDM_BIOS_ENUMERATION, attrType);
             tableData += sizeof(attrHdl) + sizeof(attrType);
             traversed += sizeof(attrHdl) + sizeof(attrType);
             numCurrVals = *tableData;
             EXPECT_EQ(1, numCurrVals);
             tableData += sizeof(numCurrVals);
             traversed += sizeof(numCurrVals);
             currValStrIndex = *tableData;
             EXPECT_EQ(0, currValStrIndex);
             tableData += numCurrVals;
             traversed += numCurrVals;
             break; // testing for first row
             if ((attrValTableLen - traversed) < 8)
             {
                 break;
             }
         }
         times++;
     }

 } // end TEST
	#include "libpldmresponder/bios.hpp"
	#include "libpldmresponder/bios_parser.hpp"
	#include "libpldmresponder/bios_table.hpp"

	#include <string.h>

	#include <array>
	#include <ctime>
	#include <filesystem>

	#include "libpldm/base.h"
	#include "libpldm/bios.h"

	#include <gtest/gtest.h>

	using namespace pldm;
	using namespace pldm::responder;
	using namespace pldm::responder::bios;
	using namespace pldm::responder::utils;
	using namespace bios_parser;
	using namespace bios_parser::bios_enum;

	TEST(epochToBCDTime, testTime)
	{
	struct tm time
	{
	};
	time.tm_year = 119;
	time.tm_mon = 3;
	time.tm_mday = 13;
	time.tm_hour = 5;
	time.tm_min = 18;
	time.tm_sec = 13;
	time.tm_isdst = -1;

	time_t epochTime = mktime(&time);
	uint8_t seconds = 0;
	uint8_t minutes = 0;
	uint8_t hours = 0;
	uint8_t day = 0;
	uint8_t month = 0;
	uint16_t year = 0;

	epochToBCDTime(epochTime, seconds, minutes, hours, day, month, year);

	ASSERT_EQ(0x13, seconds);
	ASSERT_EQ(0x18, minutes);
	ASSERT_EQ(0x5, hours);
	ASSERT_EQ(0x13, day);
	ASSERT_EQ(0x4, month);
	ASSERT_EQ(0x2019, year);
	}

	TEST(GetBIOSStrings, allScenarios)
	{
	using namespace bios_parser;
	// All the BIOS Strings in the BIOS JSON config files.
	Strings vec{"HMCManagedState", "On", "Off",
	"FWBootSide", "Perm", "Temp",
	"InbandCodeUpdate", "Allowed", "NotAllowed",
	"CodeUpdatePolicy", "Concurrent", "Disruptive",
	"str_example1", "str_example2", "str_example3"};

	Strings nullVec{};

	// Invalid directory
	auto strings = bios_parser::getStrings("./bios_json");
	ASSERT_EQ(strings == nullVec, true);

	strings = bios_parser::getStrings("./bios_jsons");
	std::sort(strings.begin(), strings.end());
	std::sort(vec.begin(), vec.end());
	ASSERT_EQ(strings == vec, true);
	}

	TEST(getAttrValue, allScenarios)
	{
	using namespace bios_parser::bios_enum;
	// All the BIOS Strings in the BIOS JSON config files.
	AttrValuesMap valueMap{
	{"HMCManagedState", {false, {"On", "Off"}, {"On"}}},
	{"FWBootSide", {false, {"Perm", "Temp"}, {"Perm"}}},
	{"InbandCodeUpdate", {false, {"Allowed", "NotAllowed"}, {"Allowed"}}},
	{"CodeUpdatePolicy",
	{false, {"Concurrent", "Disruptive"}, {"Concurrent"}}}};

	auto rc = setupValueLookup("./bios_jsons");
	ASSERT_EQ(rc, 0);

	auto values = getValues();
	ASSERT_EQ(valueMap == values, true);

	CurrentValues cv{"Concurrent"};
	auto value = getAttrValue("CodeUpdatePolicy");
	ASSERT_EQ(value == cv, true);

	// Invalid attribute name
	ASSERT_THROW(getAttrValue("CodeUpdatePolic"), std::out_of_range);
	}

	namespace fs = std::filesystem;
	class TestAllBIOSTables : public ::testing::Test
	{
	public:
	static void SetUpTestCase() // will execute once at the begining of all
	// TestAllBIOSTables objects
	{
	char tmpdir[] = "/tmp/allBiosTables.XXXXXX";
	biosPath = fs::path(mkdtemp(tmpdir));
	}

	static void TearDownTestCase() // will be executed once at th eend of all
	// TestAllBIOSTables objects
	{
	fs::remove_all(biosPath);
	}

	static fs::path biosPath;
	};

	fs::path TestAllBIOSTables::biosPath;

	TEST_F(TestAllBIOSTables, GetBIOSTableTestBadRequest)
	{
	std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
	requestPayload{};
	auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
	struct pldm_get_bios_table_req* req =
	(struct pldm_get_bios_table_req*)request->payload;
	req->transfer_handle = 9;
	req->transfer_op_flag = PLDM_GET_FIRSTPART;
	req->table_type = 0xFF;

	size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

	auto response = internal::buildBIOSTables(request, requestPayloadLength,
	"./bios_jsons", biosPath.c_str());
	auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

	struct pldm_get_bios_table_resp* resp =
	reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);

	ASSERT_EQ(PLDM_INVALID_BIOS_TABLE_TYPE, resp->completion_code);
	}

	TEST_F(TestAllBIOSTables, buildBIOSTablesTestBadRequest)
	{
	std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
	requestPayload{};
	auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
	struct pldm_get_bios_table_req* req =
	(struct pldm_get_bios_table_req*)request->payload;
	req->transfer_handle = 9;
	req->transfer_op_flag = PLDM_GET_FIRSTPART;
	req->table_type = PLDM_BIOS_ATTR_VAL_TABLE;

	size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

	auto response = internal::buildBIOSTables(request, requestPayloadLength,
	"./bios_jsons", biosPath.c_str());
	auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());
	struct pldm_get_bios_table_resp* resp =
	reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);
	ASSERT_EQ(PLDM_BIOS_TABLE_UNAVAILABLE, resp->completion_code);

	req->table_type = PLDM_BIOS_ATTR_TABLE;
	response = internal::buildBIOSTables(request, requestPayloadLength,
	"./bios_jsons", biosPath.c_str());
	responsePtr = reinterpret_cast<pldm_msg*>(response.data());
	resp = reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);
	ASSERT_EQ(PLDM_BIOS_TABLE_UNAVAILABLE, resp->completion_code);
	}

	TEST_F(TestAllBIOSTables, GetBIOSStringTableTestGoodRequest)
	{
	std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
	requestPayload{};
	auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
	struct pldm_get_bios_table_req* req =
	(struct pldm_get_bios_table_req*)request->payload;
	req->transfer_handle = 9;
	req->transfer_op_flag = PLDM_GET_FIRSTPART;
	req->table_type = PLDM_BIOS_STRING_TABLE;

	Strings biosStrings = getStrings("./bios_jsons");
	std::sort(biosStrings.begin(), biosStrings.end());
	biosStrings.erase(std::unique(biosStrings.begin(), biosStrings.end()),
	biosStrings.end());

	size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);
	uint8_t times = 0;
	while (times < 2)
	{ // first time fresh table second time existing table
	auto response = internal::buildBIOSTables(
	request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
	auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

	struct pldm_get_bios_table_resp* resp =
	reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);

	ASSERT_EQ(0, resp->completion_code);
	ASSERT_EQ(0, resp->next_transfer_handle);
	ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

	uint16_t strLen = 0;
	uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);

	for (auto elem : biosStrings)
	{
	struct pldm_bios_string_table_entry* ptr =
	reinterpret_cast<struct pldm_bios_string_table_entry*>(
	tableData);
	strLen = ptr->string_length;
	ASSERT_EQ(strLen, elem.size());
	ASSERT_EQ(0, memcmp(elem.c_str(), ptr->name, strLen));
	tableData += (sizeof(pldm_bios_string_table_entry) - 1) + strLen;

	} // end for
	times++;
	}
	}

	TEST_F(TestAllBIOSTables, getBIOSAttributeTableTestGoodRequest)
	{
	std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
	requestPayload{};
	auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
	struct pldm_get_bios_table_req* req =
	(struct pldm_get_bios_table_req*)request->payload;
	req->transfer_handle = 9;
	req->transfer_op_flag = PLDM_GET_FIRSTPART;
	req->table_type = PLDM_BIOS_ATTR_TABLE;

	size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

	uint8_t times = 0;
	while (times < 2)
	{ // first time fresh table second time existing table
	auto response = internal::buildBIOSTables(
	request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
	auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

	struct pldm_get_bios_table_resp* resp =
	reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);

	ASSERT_EQ(0, resp->completion_code);
	ASSERT_EQ(0, resp->next_transfer_handle);
	ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

	uint32_t attrTableLen =
	response.size() - sizeof(pldm_msg_hdr) -
	(sizeof(resp->completion_code) +
	sizeof(resp->next_transfer_handle) + sizeof(resp->transfer_flag));
	uint32_t traversed = 0;
	uint16_t attrHdl = 0;
	uint16_t stringHdl = 0;
	uint8_t attrType = 0;
	uint8_t numPosVals = 0;
	uint8_t numDefVals = 0;
	uint8_t defIndex = 0;

	uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);
	while (1)
	{
	struct pldm_bios_attr_table_entry* ptr =
	reinterpret_cast<struct pldm_bios_attr_table_entry*>(tableData);
	attrHdl = ptr->attr_handle;
	attrType = ptr->attr_type;
	EXPECT_EQ(0, attrHdl);
	EXPECT_EQ(PLDM_BIOS_ENUMERATION, attrType);
	stringHdl = ptr->string_handle;
	EXPECT_EQ(stringHdl, 1);
	tableData += sizeof(attrHdl) + sizeof(attrType) + sizeof(stringHdl);
	numPosVals = *tableData;
	EXPECT_EQ(numPosVals, 2);
	traversed += sizeof(attrHdl) + sizeof(attrType) + sizeof(stringHdl);
	traversed += sizeof(numPosVals);
	PossibleValuesByHandle possiVals;
	tableData++;
	uint16_t* temp = reinterpret_cast<uint16_t*>(tableData);
	uint32_t i = 0;
	while (i < numPosVals)
	{
	uint16_t val = *temp;
	possiVals.push_back(val);
	temp++;
	i++;
	}
	EXPECT_EQ(possiVals.size(), 2);
	tableData += numPosVals * sizeof(stringHdl);
	traversed += numPosVals * sizeof(stringHdl);
	numDefVals = *tableData;
	EXPECT_EQ(numDefVals, 1);
	tableData += numDefVals * sizeof(defIndex);
	traversed += numDefVals + sizeof(numDefVals);

	break; // test for first row only

	if ((attrTableLen - traversed) < 8)
	{
	// reached pad
	break;
	}

	} // end while
	times++;
	}

	} // end TEST

	TEST_F(TestAllBIOSTables, getBIOSAttributeValueTableTestGoodRequest)
	{
	std::array<uint8_t, sizeof(pldm_msg_hdr) + PLDM_GET_BIOS_TABLE_REQ_BYTES>
	requestPayload{};
	auto request = reinterpret_cast<pldm_msg*>(requestPayload.data());
	struct pldm_get_bios_table_req* req =
	(struct pldm_get_bios_table_req*)request->payload;
	req->transfer_handle = 9;
	req->transfer_op_flag = PLDM_GET_FIRSTPART;
	req->table_type = PLDM_BIOS_ATTR_VAL_TABLE;

	std::string attrName("CodeUpdatePolicy");
	CurrentValues currVals = getAttrValue(attrName);

	size_t requestPayloadLength = requestPayload.size() - sizeof(pldm_msg_hdr);

	uint8_t times = 0;
	while (times < 2)
	{ // first time frest table second time existing table
	auto response = internal::buildBIOSTables(
	request, requestPayloadLength, "./bios_jsons", biosPath.c_str());
	auto responsePtr = reinterpret_cast<pldm_msg*>(response.data());

	struct pldm_get_bios_table_resp* resp =
	reinterpret_cast<struct pldm_get_bios_table_resp*>(
	responsePtr->payload);

	ASSERT_EQ(0, resp->completion_code);
	ASSERT_EQ(0, resp->next_transfer_handle);
	ASSERT_EQ(PLDM_START_AND_END, resp->transfer_flag);

	uint32_t attrValTableLen =
	response.size() - sizeof(pldm_msg_hdr) -
	(sizeof(resp->completion_code) +
	sizeof(resp->next_transfer_handle) + sizeof(resp->transfer_flag));
	uint32_t traversed = 0;
	uint8_t* tableData = reinterpret_cast<uint8_t*>(resp->table_data);

	uint16_t attrHdl;
	uint8_t attrType;
	uint8_t numCurrVals;
	uint8_t currValStrIndex;

	while (1)
	{
	struct pldm_bios_attr_val_table_entry* ptr =
	reinterpret_cast<struct pldm_bios_attr_val_table_entry*>(
	tableData);
	attrHdl = ptr->attr_handle;
	attrType = ptr->attr_type;
	EXPECT_EQ(0, attrHdl);
	EXPECT_EQ(PLDM_BIOS_ENUMERATION, attrType);
	tableData += sizeof(attrHdl) + sizeof(attrType);
	traversed += sizeof(attrHdl) + sizeof(attrType);
	numCurrVals = *tableData;
	EXPECT_EQ(1, numCurrVals);
	tableData += sizeof(numCurrVals);
	traversed += sizeof(numCurrVals);
	currValStrIndex = *tableData;
	EXPECT_EQ(0, currValStrIndex);
	tableData += numCurrVals;
	traversed += numCurrVals;
	break; // testing for first row
	if ((attrValTableLen - traversed) < 8)
	{
	break;
	}
	}
	times++;
	}

	} // end TEST