test/openpower-pels/src_callout_test.cpp - openbmc/phosphor-logging - Gitiles

 /**
  * Copyright © 2019 IBM Corporation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 #include "extensions/openpower-pels/callout.hpp"
 #include "pel_utils.hpp"

 #include <gtest/gtest.h>

 using namespace openpower::pels;
 using namespace openpower::pels::src;

 // Unflatten the callout section with all three substructures
 TEST(CalloutTest, TestUnflattenAllSubstructures)
 {
     // The base data.
     std::vector<uint8_t> data{
         0xFF, 0x2F, 'H', 8, // size, flags, priority, LC length
         'U',  '1',  '2', '-', 'P', '1', 0x00, 0x00 // LC
     };

     auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
     auto pceIdentity = srcDataFactory(TestSRCType::pceIdentityStructure);
     auto mrus = srcDataFactory(TestSRCType::mruStructure);

     // Add all 3 substructures
     data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());
     data.insert(data.end(), pceIdentity.begin(), pceIdentity.end());
     data.insert(data.end(), mrus.begin(), mrus.end());

     // The final size
     data[0] = data.size();

     Stream stream{data};
     Callout callout{stream};

     EXPECT_EQ(callout.flattenedSize(), data.size());
     EXPECT_EQ(callout.priority(), 'H');
     EXPECT_EQ(callout.locationCode(), "U12-P1");

     // Spot check the 3 substructures
     EXPECT_TRUE(callout.fruIdentity());
     EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

     EXPECT_TRUE(callout.pceIdentity());
     EXPECT_EQ(callout.pceIdentity()->enclosureName(), "PCENAME12");

     EXPECT_TRUE(callout.mru());
     EXPECT_EQ(callout.mru()->mrus().size(), 4);
     EXPECT_EQ(callout.mru()->mrus().at(3).id, 0x04040404);

     // Now flatten
     std::vector<uint8_t> newData;
     Stream newStream{newData};

     callout.flatten(newStream);
     EXPECT_EQ(data, newData);
 }

 TEST(CalloutTest, TestUnflattenOneSubstructure)
 {
     std::vector<uint8_t> data{
         0xFF, 0x28, 'H', 0x08, // size, flags, priority, LC length
         'U',  '1',  '2', '-',  'P', '1', 0x00, 0x00 // LC
     };

     auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);

     data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());

     // The final size
     data[0] = data.size();

     Stream stream{data};
     Callout callout{stream};

     EXPECT_EQ(callout.flattenedSize(), data.size());

     // Spot check the substructure
     EXPECT_TRUE(callout.fruIdentity());
     EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

     // Not present
     EXPECT_FALSE(callout.pceIdentity());
     EXPECT_FALSE(callout.mru());

     // Now flatten
     std::vector<uint8_t> newData;
     Stream newStream{newData};

     callout.flatten(newStream);
     EXPECT_EQ(data, newData);
 }

 TEST(CalloutTest, TestUnflattenTwoSubstructures)
 {
     std::vector<uint8_t> data{
         0xFF, 0x2B, 'H', 0x08, // size, flags, priority, LC length
         'U',  '1',  '2', '-',  'P', '1', 0x00, 0x00 // LC
     };

     auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
     auto pceIdentity = srcDataFactory(TestSRCType::pceIdentityStructure);

     data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());
     data.insert(data.end(), pceIdentity.begin(), pceIdentity.end());

     // The final size
     data[0] = data.size();

     Stream stream{data};
     Callout callout{stream};

     EXPECT_EQ(callout.flattenedSize(), data.size());

     // Spot check the 2 substructures
     EXPECT_TRUE(callout.fruIdentity());
     EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

     EXPECT_TRUE(callout.pceIdentity());
     EXPECT_EQ(callout.pceIdentity()->enclosureName(), "PCENAME12");

     // Not present
     EXPECT_FALSE(callout.mru());

     // Now flatten
     std::vector<uint8_t> newData;
     Stream newStream{newData};

     callout.flatten(newStream);
     EXPECT_EQ(data, newData);
 }

 TEST(CalloutTest, TestNoLocationCode)
 {
     std::vector<uint8_t> data{
         0xFF, 0x2B, 'H', 0x00 // size, flags, priority, LC length
     };

     auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
     data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());

     // The final size
     data[0] = data.size();

     Stream stream{data};
     Callout callout{stream};

     EXPECT_TRUE(callout.locationCode().empty());
 }

 // Create a callout object by passing in the hardware fields to add
 TEST(CalloutTest, TestHardwareCallout)
 {
     constexpr size_t fruIdentitySize = 28;

     {
         Callout callout{CalloutPriority::high, "U99-42.5-P1-C2-E1", "1234567",
                         "ABCD", "123456789ABC"};

         // size/flags/pri/locsize fields +
         // rounded up location code length +
         // FRUIdentity size
         size_t size = 4 + 20 + fruIdentitySize;

         EXPECT_EQ(callout.flags(),
                   Callout::calloutType | Callout::fruIdentIncluded);

         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "U99-42.5-P1-C2-E1");
         EXPECT_EQ(callout.locationCodeSize(), 20);

         auto& fru = callout.fruIdentity();
         EXPECT_EQ(fru->getPN().value(), "1234567");
         EXPECT_EQ(fru->getCCIN().value(), "ABCD");
         EXPECT_EQ(fru->getSN().value(), "123456789ABC");
     }

     {
         // A 3B location code, plus null = 4
         Callout callout{CalloutPriority::high, "123", "1234567", "ABCD",
                         "123456789ABC"};

         size_t size = 4 + 4 + fruIdentitySize;
         EXPECT_EQ(callout.locationCodeSize(), 4);
         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.locationCode(), "123");
     }

     {
         // A 4B location code, plus null = 5, then pad to 8
         Callout callout{CalloutPriority::high, "1234", "1234567", "ABCD",
                         "123456789ABC"};

         size_t size = 4 + 8 + fruIdentitySize;
         EXPECT_EQ(callout.locationCodeSize(), 8);
         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.locationCode(), "1234");
     }

     {
         // A truncated location code (80 is max size, including null)
         std::string locCode(81, 'L');
         Callout callout{CalloutPriority::high, locCode, "1234567", "ABCD",
                         "123456789ABC"};

         size_t size = 4 + 80 + fruIdentitySize;
         EXPECT_EQ(callout.locationCodeSize(), 80);
         EXPECT_EQ(callout.flattenedSize(), size);

         // take off 1 to get to 80, and another for the null
         locCode = locCode.substr(0, locCode.size() - 2);
         EXPECT_EQ(callout.locationCode(), locCode);
     }

     {
         // A truncated location code by 1 because of the null
         std::string locCode(80, 'L');
         Callout callout{CalloutPriority::high, locCode, "1234567", "ABCD",
                         "123456789ABC"};

         size_t size = 4 + 80 + fruIdentitySize;
         EXPECT_EQ(callout.locationCodeSize(), 80);
         EXPECT_EQ(callout.flattenedSize(), size);

         locCode.pop_back();
         EXPECT_EQ(callout.locationCode(), locCode);
     }

     {
         // Max size location code
         std::string locCode(79, 'L');
         Callout callout{CalloutPriority::low, locCode, "1234567", "ABCD",
                         "123456789ABC"};

         size_t size = 4 + 80 + fruIdentitySize;
         EXPECT_EQ(callout.locationCodeSize(), 80);
         EXPECT_EQ(callout.flattenedSize(), size);

         EXPECT_EQ(callout.locationCode(), locCode);

         // How about we flatten/unflatten this last one
         std::vector<uint8_t> data;
         Stream stream{data};

         callout.flatten(stream);

         {
             Stream newStream{data};
             Callout newCallout{newStream};

             EXPECT_EQ(newCallout.flags(),
                       Callout::calloutType | Callout::fruIdentIncluded);

             EXPECT_EQ(newCallout.flattenedSize(), callout.flattenedSize());
             EXPECT_EQ(newCallout.priority(), callout.priority());
             EXPECT_EQ(newCallout.locationCode(), callout.locationCode());
             EXPECT_EQ(newCallout.locationCodeSize(),
                       callout.locationCodeSize());

             auto& fru = newCallout.fruIdentity();
             EXPECT_EQ(fru->getPN().value(), "1234567");
             EXPECT_EQ(fru->getCCIN().value(), "ABCD");
             EXPECT_EQ(fru->getSN().value(), "123456789ABC");
         }
     }

     {
         // With MRUs
         std::vector<MRU::MRUCallout> mruList{{'H', 1}, {'H', 2}};

         Callout callout{CalloutPriority::high, "U99-P5", "1234567", "ABCD",
                         "123456789ABC",        mruList};

         EXPECT_EQ(callout.flags(),
                   Callout::calloutType | Callout::fruIdentIncluded |
                       Callout::mruIncluded);

         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "U99-P5");
         EXPECT_EQ(callout.locationCodeSize(), 8);

         auto& fru = callout.fruIdentity();
         EXPECT_EQ(fru->getPN().value(), "1234567");
         EXPECT_EQ(fru->getCCIN().value(), "ABCD");
         EXPECT_EQ(fru->getSN().value(), "123456789ABC");

         auto& mruSection = callout.mru();
         EXPECT_EQ(mruSection->mrus().size(), 2);
         EXPECT_EQ(mruSection->mrus().at(0).priority, 'H');
         EXPECT_EQ(mruSection->mrus().at(0).id, 1);
         EXPECT_EQ(mruSection->mrus().at(1).priority, 'H');
         EXPECT_EQ(mruSection->mrus().at(1).id, 2);
     }
 }

 // Create a callout object by passing in the maintenance procedure to add.
 TEST(CalloutTest, TestProcedureCallout)
 {
     Callout callout{CalloutPriority::medium, "bmc_code"};

     // size/flags/pri/locsize fields + FRUIdentity size
     // No location code.
     size_t size = 4 + 12;

     EXPECT_EQ(callout.flags(),
               Callout::calloutType | Callout::fruIdentIncluded);

     EXPECT_EQ(callout.flattenedSize(), size);
     EXPECT_EQ(callout.priority(), 'M');
     EXPECT_EQ(callout.locationCode(), "");
     EXPECT_EQ(callout.locationCodeSize(), 0);

     auto& fru = callout.fruIdentity();
     EXPECT_EQ(fru->getMaintProc().value(), "BMC0001");

     // flatten/unflatten
     std::vector<uint8_t> data;
     Stream stream{data};

     callout.flatten(stream);

     Stream newStream{data};
     Callout newCallout{newStream};

     EXPECT_EQ(newCallout.flags(),
               Callout::calloutType | Callout::fruIdentIncluded);

     EXPECT_EQ(newCallout.flattenedSize(), callout.flattenedSize());
     EXPECT_EQ(newCallout.priority(), callout.priority());
     EXPECT_EQ(newCallout.locationCode(), callout.locationCode());
     EXPECT_EQ(newCallout.locationCodeSize(), callout.locationCodeSize());

     auto& newFRU = newCallout.fruIdentity();
     EXPECT_EQ(newFRU->getMaintProc().value(), fru->getMaintProc().value());

     // Use raw procedure value

     Callout rawCallout{CalloutPriority::medium, "BMCXXXX",
                        CalloutValueType::raw};
     auto& rawFRU = rawCallout.fruIdentity();
     EXPECT_EQ(rawFRU->getMaintProc().value(), "BMCXXXX");
 }

 // Create a callout object by passing in the symbolic FRU to add.
 TEST(CalloutTest, TestSymbolicFRUCallout)
 {
     // symbolic FRU with a location code
     {
         Callout callout{CalloutPriority::high, "service_docs", "P1-C3", false};

         // size/flags/pri/locsize fields + plus loc + FRUIdentity size
         size_t size = 4 + 8 + 12;

         EXPECT_EQ(callout.flags(),
                   Callout::calloutType | Callout::fruIdentIncluded);

         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "P1-C3");
         EXPECT_EQ(callout.locationCodeSize(), 8);

         auto& fru = callout.fruIdentity();

         EXPECT_EQ(fru->failingComponentType(), FRUIdentity::symbolicFRU);
         EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
     }

     // symbolic FRU without a location code
     {
         Callout callout{CalloutPriority::high, "service_docs", "", false};

         // size/flags/pri/locsize fields + plus loc + FRUIdentity size
         size_t size = 4 + 0 + 12;

         EXPECT_EQ(callout.flags(),
                   Callout::calloutType | Callout::fruIdentIncluded);

         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "");
         EXPECT_EQ(callout.locationCodeSize(), 0);

         auto& fru = callout.fruIdentity();

         EXPECT_EQ(fru->failingComponentType(), FRUIdentity::symbolicFRU);
         EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
     }

     // symbolic FRU with a trusted location code
     {
         Callout callout{CalloutPriority::high, "service_docs", "P1-C3", true};

         // size/flags/pri/locsize fields + plus loc + FRUIdentity size
         size_t size = 4 + 8 + 12;

         EXPECT_EQ(callout.flags(),
                   Callout::calloutType | Callout::fruIdentIncluded);

         EXPECT_EQ(callout.flattenedSize(), size);
         EXPECT_EQ(callout.priority(), 'H');
         EXPECT_EQ(callout.locationCode(), "P1-C3");
         EXPECT_EQ(callout.locationCodeSize(), 8);

         auto& fru = callout.fruIdentity();
         EXPECT_EQ(fru->failingComponentType(),
                   FRUIdentity::symbolicFRUTrustedLocCode);
         EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
     }

     // symbolic FRU with raw FRU value
     {
         {
             Callout callout{CalloutPriority::high, "SYMBFRU",
                             CalloutValueType::raw, "", false};

             auto& fru = callout.fruIdentity();

             EXPECT_EQ(fru->getPN().value(), "SYMBFRU");
         }
     }
 }

 TEST(CalloutTest, OperatorEqualTest)
 {
     {
         Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         Callout c2{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         EXPECT_EQ(c1, c2);
     }

     {
         // Different location code
         Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         Callout c2{CalloutPriority::high, "A2", "1234567", "ABCD",
                    "123456789ABC"};
         EXPECT_NE(c1, c2);
     }

     {
         // maintenance procedure
         Callout c1{CalloutPriority::medium, "bmc_code"};
         Callout c2{CalloutPriority::medium, "bmc_code"};
         EXPECT_EQ(c1, c2);
     }

     {
         // different maintenance procedures
         Callout c1{CalloutPriority::medium, "bmc_code"};
         Callout c2{CalloutPriority::medium, "sbe_code"};
         EXPECT_NE(c1, c2);
     }

     {
         // symbolic FRU
         Callout c1{CalloutPriority::high, "service_docs", "", false};
         Callout c2{CalloutPriority::high, "service_docs", "", false};
         EXPECT_EQ(c1, c2);
     }

     {
         // different symbolic FRUs
         Callout c1{CalloutPriority::high, "service_docs", "", false};
         Callout c2{CalloutPriority::high, "air_mover", "", false};
         EXPECT_NE(c1, c2);
     }

     {
         // HW callout vs symbolic FRU
         Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         Callout c2{CalloutPriority::high, "service_docs", "", false};
         EXPECT_NE(c1, c2);
     }

     {
         // HW callout vs maintenance procedure
         Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         Callout c2{CalloutPriority::medium, "bmc_code"};
         EXPECT_NE(c1, c2);
     }

     {
         // symbolic FRU vs maintenance procedure
         Callout c1{CalloutPriority::high, "service_docs", "", false};
         Callout c2{CalloutPriority::medium, "bmc_code"};
         EXPECT_NE(c1, c2);
     }

     {
         // HW callout vs symbolic FRU is still considered equal if
         // the location code is the same
         Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
                    "123456789ABC"};
         Callout c2{CalloutPriority::high, "service_docs", "A1", true};
         EXPECT_EQ(c1, c2);
     }
 }

 TEST(CalloutTest, OperatorGreaterThanTest)
 {
     {
         Callout c1{CalloutPriority::high, "bmc_code"};
         Callout c2{CalloutPriority::medium, "bmc_code"};
         EXPECT_TRUE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::high, "bmc_code"};
         Callout c2{CalloutPriority::low, "bmc_code"};
         EXPECT_TRUE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::medium, "bmc_code"};
         Callout c2{CalloutPriority::low, "bmc_code"};
         EXPECT_TRUE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::mediumGroupA, "bmc_code"};
         Callout c2{CalloutPriority::low, "bmc_code"};
         EXPECT_TRUE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::medium, "bmc_code"};
         Callout c2{CalloutPriority::high, "bmc_code"};
         EXPECT_FALSE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::high, "bmc_code"};
         Callout c2{CalloutPriority::high, "bmc_code"};
         EXPECT_FALSE(c1 > c2);
     }
     {
         Callout c1{CalloutPriority::low, "bmc_code"};
         Callout c2{CalloutPriority::high, "bmc_code"};
         EXPECT_FALSE(c1 > c2);
     }
     {
         // Treat the different mediums the same
         Callout c1{CalloutPriority::medium, "bmc_code"};
         Callout c2{CalloutPriority::mediumGroupA, "bmc_code"};
         EXPECT_FALSE(c1 > c2);
     }
 }
	/**
	* Copyright © 2019 IBM Corporation
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	#include "extensions/openpower-pels/callout.hpp"
	#include "pel_utils.hpp"

	#include <gtest/gtest.h>

	using namespace openpower::pels;
	using namespace openpower::pels::src;

	// Unflatten the callout section with all three substructures
	TEST(CalloutTest, TestUnflattenAllSubstructures)
	{
	// The base data.
	std::vector<uint8_t> data{
	0xFF, 0x2F, 'H', 8, // size, flags, priority, LC length
	'U', '1', '2', '-', 'P', '1', 0x00, 0x00 // LC
	};

	auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
	auto pceIdentity = srcDataFactory(TestSRCType::pceIdentityStructure);
	auto mrus = srcDataFactory(TestSRCType::mruStructure);

	// Add all 3 substructures
	data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());
	data.insert(data.end(), pceIdentity.begin(), pceIdentity.end());
	data.insert(data.end(), mrus.begin(), mrus.end());

	// The final size
	data[0] = data.size();

	Stream stream{data};
	Callout callout{stream};

	EXPECT_EQ(callout.flattenedSize(), data.size());
	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "U12-P1");

	// Spot check the 3 substructures
	EXPECT_TRUE(callout.fruIdentity());
	EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

	EXPECT_TRUE(callout.pceIdentity());
	EXPECT_EQ(callout.pceIdentity()->enclosureName(), "PCENAME12");

	EXPECT_TRUE(callout.mru());
	EXPECT_EQ(callout.mru()->mrus().size(), 4);
	EXPECT_EQ(callout.mru()->mrus().at(3).id, 0x04040404);

	// Now flatten
	std::vector<uint8_t> newData;
	Stream newStream{newData};

	callout.flatten(newStream);
	EXPECT_EQ(data, newData);
	}

	TEST(CalloutTest, TestUnflattenOneSubstructure)
	{
	std::vector<uint8_t> data{
	0xFF, 0x28, 'H', 0x08, // size, flags, priority, LC length
	'U', '1', '2', '-', 'P', '1', 0x00, 0x00 // LC
	};

	auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);

	data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());

	// The final size
	data[0] = data.size();

	Stream stream{data};
	Callout callout{stream};

	EXPECT_EQ(callout.flattenedSize(), data.size());

	// Spot check the substructure
	EXPECT_TRUE(callout.fruIdentity());
	EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

	// Not present
	EXPECT_FALSE(callout.pceIdentity());
	EXPECT_FALSE(callout.mru());

	// Now flatten
	std::vector<uint8_t> newData;
	Stream newStream{newData};

	callout.flatten(newStream);
	EXPECT_EQ(data, newData);
	}

	TEST(CalloutTest, TestUnflattenTwoSubstructures)
	{
	std::vector<uint8_t> data{
	0xFF, 0x2B, 'H', 0x08, // size, flags, priority, LC length
	'U', '1', '2', '-', 'P', '1', 0x00, 0x00 // LC
	};

	auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
	auto pceIdentity = srcDataFactory(TestSRCType::pceIdentityStructure);

	data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());
	data.insert(data.end(), pceIdentity.begin(), pceIdentity.end());

	// The final size
	data[0] = data.size();

	Stream stream{data};
	Callout callout{stream};

	EXPECT_EQ(callout.flattenedSize(), data.size());

	// Spot check the 2 substructures
	EXPECT_TRUE(callout.fruIdentity());
	EXPECT_EQ(callout.fruIdentity()->getSN(), "123456789ABC");

	EXPECT_TRUE(callout.pceIdentity());
	EXPECT_EQ(callout.pceIdentity()->enclosureName(), "PCENAME12");

	// Not present
	EXPECT_FALSE(callout.mru());

	// Now flatten
	std::vector<uint8_t> newData;
	Stream newStream{newData};

	callout.flatten(newStream);
	EXPECT_EQ(data, newData);
	}

	TEST(CalloutTest, TestNoLocationCode)
	{
	std::vector<uint8_t> data{
	0xFF, 0x2B, 'H', 0x00 // size, flags, priority, LC length
	};

	auto fruIdentity = srcDataFactory(TestSRCType::fruIdentityStructure);
	data.insert(data.end(), fruIdentity.begin(), fruIdentity.end());

	// The final size
	data[0] = data.size();

	Stream stream{data};
	Callout callout{stream};

	EXPECT_TRUE(callout.locationCode().empty());
	}

	// Create a callout object by passing in the hardware fields to add
	TEST(CalloutTest, TestHardwareCallout)
	{
	constexpr size_t fruIdentitySize = 28;

	{
	Callout callout{CalloutPriority::high, "U99-42.5-P1-C2-E1", "1234567",
	"ABCD", "123456789ABC"};

	// size/flags/pri/locsize fields +
	// rounded up location code length +
	// FRUIdentity size
	size_t size = 4 + 20 + fruIdentitySize;

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "U99-42.5-P1-C2-E1");
	EXPECT_EQ(callout.locationCodeSize(), 20);

	auto& fru = callout.fruIdentity();
	EXPECT_EQ(fru->getPN().value(), "1234567");
	EXPECT_EQ(fru->getCCIN().value(), "ABCD");
	EXPECT_EQ(fru->getSN().value(), "123456789ABC");
	}

	{
	// A 3B location code, plus null = 4
	Callout callout{CalloutPriority::high, "123", "1234567", "ABCD",
	"123456789ABC"};

	size_t size = 4 + 4 + fruIdentitySize;
	EXPECT_EQ(callout.locationCodeSize(), 4);
	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.locationCode(), "123");
	}

	{
	// A 4B location code, plus null = 5, then pad to 8
	Callout callout{CalloutPriority::high, "1234", "1234567", "ABCD",
	"123456789ABC"};

	size_t size = 4 + 8 + fruIdentitySize;
	EXPECT_EQ(callout.locationCodeSize(), 8);
	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.locationCode(), "1234");
	}

	{
	// A truncated location code (80 is max size, including null)
	std::string locCode(81, 'L');
	Callout callout{CalloutPriority::high, locCode, "1234567", "ABCD",
	"123456789ABC"};

	size_t size = 4 + 80 + fruIdentitySize;
	EXPECT_EQ(callout.locationCodeSize(), 80);
	EXPECT_EQ(callout.flattenedSize(), size);

	// take off 1 to get to 80, and another for the null
	locCode = locCode.substr(0, locCode.size() - 2);
	EXPECT_EQ(callout.locationCode(), locCode);
	}

	{
	// A truncated location code by 1 because of the null
	std::string locCode(80, 'L');
	Callout callout{CalloutPriority::high, locCode, "1234567", "ABCD",
	"123456789ABC"};

	size_t size = 4 + 80 + fruIdentitySize;
	EXPECT_EQ(callout.locationCodeSize(), 80);
	EXPECT_EQ(callout.flattenedSize(), size);

	locCode.pop_back();
	EXPECT_EQ(callout.locationCode(), locCode);
	}

	{
	// Max size location code
	std::string locCode(79, 'L');
	Callout callout{CalloutPriority::low, locCode, "1234567", "ABCD",
	"123456789ABC"};

	size_t size = 4 + 80 + fruIdentitySize;
	EXPECT_EQ(callout.locationCodeSize(), 80);
	EXPECT_EQ(callout.flattenedSize(), size);

	EXPECT_EQ(callout.locationCode(), locCode);

	// How about we flatten/unflatten this last one
	std::vector<uint8_t> data;
	Stream stream{data};

	callout.flatten(stream);

	{
	Stream newStream{data};
	Callout newCallout{newStream};

	EXPECT_EQ(newCallout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(newCallout.flattenedSize(), callout.flattenedSize());
	EXPECT_EQ(newCallout.priority(), callout.priority());
	EXPECT_EQ(newCallout.locationCode(), callout.locationCode());
	EXPECT_EQ(newCallout.locationCodeSize(),
	callout.locationCodeSize());

	auto& fru = newCallout.fruIdentity();
	EXPECT_EQ(fru->getPN().value(), "1234567");
	EXPECT_EQ(fru->getCCIN().value(), "ABCD");
	EXPECT_EQ(fru->getSN().value(), "123456789ABC");
	}
	}

	{
	// With MRUs
	std::vector<MRU::MRUCallout> mruList{{'H', 1}, {'H', 2}};

	Callout callout{CalloutPriority::high, "U99-P5", "1234567", "ABCD",
	"123456789ABC", mruList};

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded \|
	Callout::mruIncluded);

	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "U99-P5");
	EXPECT_EQ(callout.locationCodeSize(), 8);

	auto& fru = callout.fruIdentity();
	EXPECT_EQ(fru->getPN().value(), "1234567");
	EXPECT_EQ(fru->getCCIN().value(), "ABCD");
	EXPECT_EQ(fru->getSN().value(), "123456789ABC");

	auto& mruSection = callout.mru();
	EXPECT_EQ(mruSection->mrus().size(), 2);
	EXPECT_EQ(mruSection->mrus().at(0).priority, 'H');
	EXPECT_EQ(mruSection->mrus().at(0).id, 1);
	EXPECT_EQ(mruSection->mrus().at(1).priority, 'H');
	EXPECT_EQ(mruSection->mrus().at(1).id, 2);
	}
	}

	// Create a callout object by passing in the maintenance procedure to add.
	TEST(CalloutTest, TestProcedureCallout)
	{
	Callout callout{CalloutPriority::medium, "bmc_code"};

	// size/flags/pri/locsize fields + FRUIdentity size
	// No location code.
	size_t size = 4 + 12;

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.priority(), 'M');
	EXPECT_EQ(callout.locationCode(), "");
	EXPECT_EQ(callout.locationCodeSize(), 0);

	auto& fru = callout.fruIdentity();
	EXPECT_EQ(fru->getMaintProc().value(), "BMC0001");

	// flatten/unflatten
	std::vector<uint8_t> data;
	Stream stream{data};

	callout.flatten(stream);

	Stream newStream{data};
	Callout newCallout{newStream};

	EXPECT_EQ(newCallout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(newCallout.flattenedSize(), callout.flattenedSize());
	EXPECT_EQ(newCallout.priority(), callout.priority());
	EXPECT_EQ(newCallout.locationCode(), callout.locationCode());
	EXPECT_EQ(newCallout.locationCodeSize(), callout.locationCodeSize());

	auto& newFRU = newCallout.fruIdentity();
	EXPECT_EQ(newFRU->getMaintProc().value(), fru->getMaintProc().value());

	// Use raw procedure value

	Callout rawCallout{CalloutPriority::medium, "BMCXXXX",
	CalloutValueType::raw};
	auto& rawFRU = rawCallout.fruIdentity();
	EXPECT_EQ(rawFRU->getMaintProc().value(), "BMCXXXX");
	}

	// Create a callout object by passing in the symbolic FRU to add.
	TEST(CalloutTest, TestSymbolicFRUCallout)
	{
	// symbolic FRU with a location code
	{
	Callout callout{CalloutPriority::high, "service_docs", "P1-C3", false};

	// size/flags/pri/locsize fields + plus loc + FRUIdentity size
	size_t size = 4 + 8 + 12;

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "P1-C3");
	EXPECT_EQ(callout.locationCodeSize(), 8);

	auto& fru = callout.fruIdentity();

	EXPECT_EQ(fru->failingComponentType(), FRUIdentity::symbolicFRU);
	EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
	}

	// symbolic FRU without a location code
	{
	Callout callout{CalloutPriority::high, "service_docs", "", false};

	// size/flags/pri/locsize fields + plus loc + FRUIdentity size
	size_t size = 4 + 0 + 12;

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "");
	EXPECT_EQ(callout.locationCodeSize(), 0);

	auto& fru = callout.fruIdentity();

	EXPECT_EQ(fru->failingComponentType(), FRUIdentity::symbolicFRU);
	EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
	}

	// symbolic FRU with a trusted location code
	{
	Callout callout{CalloutPriority::high, "service_docs", "P1-C3", true};

	// size/flags/pri/locsize fields + plus loc + FRUIdentity size
	size_t size = 4 + 8 + 12;

	EXPECT_EQ(callout.flags(),
	Callout::calloutType \| Callout::fruIdentIncluded);

	EXPECT_EQ(callout.flattenedSize(), size);
	EXPECT_EQ(callout.priority(), 'H');
	EXPECT_EQ(callout.locationCode(), "P1-C3");
	EXPECT_EQ(callout.locationCodeSize(), 8);

	auto& fru = callout.fruIdentity();
	EXPECT_EQ(fru->failingComponentType(),
	FRUIdentity::symbolicFRUTrustedLocCode);
	EXPECT_EQ(fru->getPN().value(), "SVCDOCS");
	}

	// symbolic FRU with raw FRU value
	{
	{
	Callout callout{CalloutPriority::high, "SYMBFRU",
	CalloutValueType::raw, "", false};

	auto& fru = callout.fruIdentity();

	EXPECT_EQ(fru->getPN().value(), "SYMBFRU");
	}
	}
	}

	TEST(CalloutTest, OperatorEqualTest)
	{
	{
	Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	Callout c2{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	EXPECT_EQ(c1, c2);
	}

	{
	// Different location code
	Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	Callout c2{CalloutPriority::high, "A2", "1234567", "ABCD",
	"123456789ABC"};
	EXPECT_NE(c1, c2);
	}

	{
	// maintenance procedure
	Callout c1{CalloutPriority::medium, "bmc_code"};
	Callout c2{CalloutPriority::medium, "bmc_code"};
	EXPECT_EQ(c1, c2);
	}

	{
	// different maintenance procedures
	Callout c1{CalloutPriority::medium, "bmc_code"};
	Callout c2{CalloutPriority::medium, "sbe_code"};
	EXPECT_NE(c1, c2);
	}

	{
	// symbolic FRU
	Callout c1{CalloutPriority::high, "service_docs", "", false};
	Callout c2{CalloutPriority::high, "service_docs", "", false};
	EXPECT_EQ(c1, c2);
	}

	{
	// different symbolic FRUs
	Callout c1{CalloutPriority::high, "service_docs", "", false};
	Callout c2{CalloutPriority::high, "air_mover", "", false};
	EXPECT_NE(c1, c2);
	}

	{
	// HW callout vs symbolic FRU
	Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	Callout c2{CalloutPriority::high, "service_docs", "", false};
	EXPECT_NE(c1, c2);
	}

	{
	// HW callout vs maintenance procedure
	Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	Callout c2{CalloutPriority::medium, "bmc_code"};
	EXPECT_NE(c1, c2);
	}

	{
	// symbolic FRU vs maintenance procedure
	Callout c1{CalloutPriority::high, "service_docs", "", false};
	Callout c2{CalloutPriority::medium, "bmc_code"};
	EXPECT_NE(c1, c2);
	}

	{
	// HW callout vs symbolic FRU is still considered equal if
	// the location code is the same
	Callout c1{CalloutPriority::high, "A1", "1234567", "ABCD",
	"123456789ABC"};
	Callout c2{CalloutPriority::high, "service_docs", "A1", true};
	EXPECT_EQ(c1, c2);
	}
	}

	TEST(CalloutTest, OperatorGreaterThanTest)
	{
	{
	Callout c1{CalloutPriority::high, "bmc_code"};
	Callout c2{CalloutPriority::medium, "bmc_code"};
	EXPECT_TRUE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::high, "bmc_code"};
	Callout c2{CalloutPriority::low, "bmc_code"};
	EXPECT_TRUE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::medium, "bmc_code"};
	Callout c2{CalloutPriority::low, "bmc_code"};
	EXPECT_TRUE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::mediumGroupA, "bmc_code"};
	Callout c2{CalloutPriority::low, "bmc_code"};
	EXPECT_TRUE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::medium, "bmc_code"};
	Callout c2{CalloutPriority::high, "bmc_code"};
	EXPECT_FALSE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::high, "bmc_code"};
	Callout c2{CalloutPriority::high, "bmc_code"};
	EXPECT_FALSE(c1 > c2);
	}
	{
	Callout c1{CalloutPriority::low, "bmc_code"};
	Callout c2{CalloutPriority::high, "bmc_code"};
	EXPECT_FALSE(c1 > c2);
	}
	{
	// Treat the different mediums the same
	Callout c1{CalloutPriority::medium, "bmc_code"};
	Callout c2{CalloutPriority::mediumGroupA, "bmc_code"};
	EXPECT_FALSE(c1 > c2);
	}
	}