DynamicTablesPkg/Library/Acpi/Common/AcpiHmatLib/GoogleTest/HmatGeneratorGoogleTest.cpp - edk2 - Git at Google

 /** @file
   Unit tests for HMAT Generator

   Copyright (c) 2026, Google LLC. All rights reserved. <BR>

   SPDX-License-Identifier: BSD-2-Clause-Patent
 **/

 #include "Base.h"
 #include <gtest/gtest.h>
 #include <gmock/gmock.h>
 #include <Library/GoogleTestLib.h>

 extern "C" {
   #include <Uefi.h>
   #include <Protocol/ConfigurationManagerProtocol.h>
   #include <Library/FunctionMockLib.h>
   #include <Library/BaseMemoryLib.h>
   #include <Library/DebugLib.h>
   #include <Library/MemoryAllocationLib.h>
   #include <Library/TableHelperLib.h>
   #include <Library/MetadataObjLib.h>
   #include <AcpiTableGenerator.h>
   #include <ConfigurationManagerObject.h>
   #include <ConfigurationManagerHelper.h>
   #include <StandardNameSpaceObjects.h>
   #include <IndustryStandard/Acpi64.h>
   #include "GoogleTest/Protocol/MockConfigurationManagerProtocol.h"
   #include "Library/Common/MetadataHandlerLib/MetadataHandler.h"

   EFI_STATUS
   EFIAPI
   AcpiHmatLibConstructor (
     IN EFI_HANDLE        ImageHandle,
     IN EFI_SYSTEM_TABLE  *SystemTable
     );

   EFI_STATUS
   EFIAPI
   AcpiHmatLibDestructor (
     IN EFI_HANDLE        ImageHandle,
     IN EFI_SYSTEM_TABLE  *SystemTable
     );

   // Global generator instance
   static ACPI_TABLE_GENERATOR  *gHmatGenerator = NULL;

   static METADATA_ROOT_HANDLE  mMetadataRoot;

   // C++ wrapper functions for C linkage functions
   EFI_STATUS
   RegisterAcpiTableGenerator (
     IN  CONST ACPI_TABLE_GENERATOR  *CONST  TableGenerator
     )
   {
     if (TableGenerator == NULL) {
       return EFI_INVALID_PARAMETER;
     }

     gHmatGenerator = const_cast<ACPI_TABLE_GENERATOR *>(TableGenerator);
     return EFI_SUCCESS;
   }

   EFI_STATUS
   DeregisterAcpiTableGenerator (
     IN  CONST ACPI_TABLE_GENERATOR  *CONST  TableGenerator
     )
   {
     if (TableGenerator == NULL) {
       return EFI_INVALID_PARAMETER;
     }

     // Clear the stored generator
     gHmatGenerator = NULL;
     return EFI_SUCCESS;
   }

   METADATA_ROOT_HANDLE
   EFIAPI
   GetMetadataRoot (
     VOID
     )
   {
     return mMetadataRoot;
   }
 }

 using namespace testing;
 using ::testing::_;
 using ::testing::NiceMock;
 using ::testing::Return;
 using ::testing::DoAll;
 using ::testing::SetArgPointee;
 using ::testing::AtLeast;

 class HmatGeneratorTest : public ::testing::Test {
 protected:
   MockConfigurationManagerProtocol MockConfigMgrProtocol;
   CM_STD_OBJ_CONFIGURATION_MANAGER_INFO CfgMgrInfo = { 0 };

   void
   ValidateMemProximityDomainAttrInfo (
     const EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES  *Expected,
     const EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES  *Actual
     )
   {
     EXPECT_EQ (Actual->Type, Expected->Type);
     EXPECT_EQ (Actual->Length, sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES));
     EXPECT_EQ (Actual->Flags.InitiatorProximityDomainValid, Expected->Flags.InitiatorProximityDomainValid);
     EXPECT_EQ (Actual->InitiatorProximityDomain, Expected->InitiatorProximityDomain);
     EXPECT_EQ (Actual->MemoryProximityDomain, Expected->MemoryProximityDomain);
   }

   void
   ValidateSSLBI (
     const EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO  *ExpectedBase,
     const UINT32                                                                  *ExpectedInitiatorDomains,
     const UINT32                                                                  *ExpectedTargetDomains,
     const UINT16                                                                  *ExpectedLatencyMatrix,
     const EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO  *Actual
     )
   {
     EXPECT_EQ (Actual->Type, ExpectedBase->Type);
     EXPECT_EQ (Actual->Length, ExpectedBase->Length);
     EXPECT_EQ (Actual->Flags.AccessAttributes, ExpectedBase->Flags.AccessAttributes);
     EXPECT_EQ (Actual->Flags.MemoryHierarchy, ExpectedBase->Flags.MemoryHierarchy);
     EXPECT_EQ (Actual->DataType, ExpectedBase->DataType);
     EXPECT_EQ (Actual->NumberOfInitiatorProximityDomains, ExpectedBase->NumberOfInitiatorProximityDomains);
     EXPECT_EQ (Actual->NumberOfTargetProximityDomains, ExpectedBase->NumberOfTargetProximityDomains);
     EXPECT_EQ (Actual->EntryBaseUnit, ExpectedBase->EntryBaseUnit);

     UINT8   *Ptr                    = (UINT8 *)Actual;
     UINT32  *ActualInitiatorDomains = (UINT32 *)(Ptr + sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO));

     for (UINT32 i = 0; i < ExpectedBase->NumberOfInitiatorProximityDomains; i++) {
       EXPECT_EQ (ActualInitiatorDomains[i], ExpectedInitiatorDomains[i]);
     }

     UINT32  *ActualTargetDomains = (UINT32 *)(ActualInitiatorDomains + ExpectedBase->NumberOfInitiatorProximityDomains);

     for (UINT32 i = 0; i < ExpectedBase->NumberOfTargetProximityDomains; i++) {
       EXPECT_EQ (ActualTargetDomains[i], ExpectedTargetDomains[i]);
     }

     UINT16  *ActualLatencyMatrix = (UINT16 *)(ActualTargetDomains + ExpectedBase->NumberOfTargetProximityDomains);

     for (UINT32 i = 0; i < ExpectedBase->NumberOfInitiatorProximityDomains * ExpectedBase->NumberOfTargetProximityDomains; i++) {
       EXPECT_EQ (ActualLatencyMatrix[i], ExpectedLatencyMatrix[i]);
     }
   }

   void
   SetUp (
     ) override
   {
     // Set up default behavior for GetObject
     ON_CALL (MockConfigMgrProtocol, GetObject (_, _, _, _))
       .WillByDefault (Return (EFI_NOT_FOUND));

     // Set up configuration manager info
     CfgMgrInfo.Revision = CREATE_REVISION (1, 0);
     CfgMgrInfo.OemId[0] = 'T';
     CfgMgrInfo.OemId[1] = 'E';
     CfgMgrInfo.OemId[2] = 'S';
     CfgMgrInfo.OemId[3] = 'T';
     CfgMgrInfo.OemId[4] = 'M';
     CfgMgrInfo.OemId[5] = 'E';

     EXPECT_CALL (MockConfigMgrProtocol, GetObject (_, CREATE_CM_STD_OBJECT_ID (EStdObjCfgMgrInfo), CM_NULL_TOKEN, _))
       .WillRepeatedly (
          DoAll (
            SetArgPointee<3>(
              CM_OBJ_DESCRIPTOR {
       CREATE_CM_STD_OBJECT_ID (EStdObjCfgMgrInfo),
       sizeof (CM_STD_OBJ_CONFIGURATION_MANAGER_INFO),
       &CfgMgrInfo,
       1
     }
              ),
            Return (EFI_SUCCESS)
            )
          );

     EXPECT_CALL (
       MockConfigMgrProtocol,
       GetObject (
         _,
         CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
         _,
         _
         )
       )
       .WillRepeatedly (
          Invoke (WRAP_ACCESSOR (GetProximityDomainInfo))
          );

     EXPECT_CALL (
       MockConfigMgrProtocol,
       GetObject (
         _,
         CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryProximityDomainAttrInfo),
         CM_NULL_TOKEN,
         _
         )
       )
       .WillRepeatedly (
          Invoke (WRAP_ACCESSOR (GetMemProximityDomainAttrInfo))
          );

     EXPECT_CALL (
       MockConfigMgrProtocol,
       GetObject (
         _,
         CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryLatBwInfo),
         CM_NULL_TOKEN,
         _
         )
       )
       .WillRepeatedly (
          Invoke (WRAP_ACCESSOR (GetMemLatBwInfo))
          );

     EXPECT_CALL (
       MockConfigMgrProtocol,
       GetObject (
         _,
         CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainRelationInfo),
         _,
         _
         )
       )
       .WillRepeatedly (
          Invoke (WRAP_ACCESSOR (GetProximityDomainRelationInfo))
          );

     // Initialize the HMAT library with our mock protocol
     EXPECT_EQ (AcpiHmatLibConstructor (NULL, NULL), EFI_SUCCESS);

     // Setup common test data with proper initialization
     mAcpiTableInfo.TableGeneratorId   = CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdHmat);
     mAcpiTableInfo.AcpiTableSignature = EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_SIGNATURE;
     mAcpiTableInfo.AcpiTableRevision  = EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_REVISION;

     MetadataInitializeHandle (&mMetadataRoot);
   }

   void
   TearDown (
     ) override
   {
     if (mTableUnderTest != nullptr) {
       gHmatGenerator->FreeTableResources (
                         gHmatGenerator,
                         &mAcpiTableInfo,
                         gConfigurationManagerProtocol,
                         &mTableUnderTest
                         );
     }

     // Clean up the HMAT library
     AcpiHmatLibDestructor (NULL, NULL);
     MetadataFreeHandle (mMetadataRoot);
   }

   void
   SetupProximityDomainInfo (
     UINT64  ProximityDomainInfoCount
     )
   {
     mProximityDomainInfo.resize (ProximityDomainInfoCount);
     for (UINT64 i = 0; i < ProximityDomainInfoCount; i++) {
       mProximityDomainInfo[i].GenerateDomainId = FALSE;
       mProximityDomainInfo[i].DomainId         = 100 + (UINT32)i;
     }
   }

   void
   SetupMemProximityDomainAttrInfo (
     CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO  *MemProximityDomainAttrInfo,
     UINT64                                            MemProximityDomainAttrInfoCount
     )
   {
     mMemProximityDomainAttrInfo.resize (MemProximityDomainAttrInfoCount);
     for (UINT64 i = 0; i < MemProximityDomainAttrInfoCount; i++) {
       mMemProximityDomainAttrInfo[i] = MemProximityDomainAttrInfo[i];
     }
   }

   void
   SetupMemLatBwInfo (
     CM_ARCH_COMMON_MEMORY_LAT_BW_INFO  *MemLatBwInfo,
     UINT64                             MemLatBwInfoCount
     )
   {
     mMemLatBwInfo.resize (MemLatBwInfoCount);
     for (UINT64 i = 0; i < MemLatBwInfoCount; i++) {
       mMemLatBwInfo[i] = MemLatBwInfo[i];
     }
   }

   void
   SetupProximityDomainRelationInfo (
     CM_OBJECT_TOKEN                                Token,
     CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO  *Matrix,
     UINT64                                         MatrixCount
     )
   {
     mProximityDomainRelationInfo[Token].resize (MatrixCount);
     for (UINT64 i = 0; i < MatrixCount; i++) {
       mProximityDomainRelationInfo[Token][i] = Matrix[i];
     }
   }

   EFI_STATUS
   GetProximityDomainInfo (
     IN  CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL  *This,
     IN  CONST CM_OBJECT_ID                          CmObjectId,
     IN  CONST CM_OBJECT_TOKEN                       Token,
     IN  OUT   CM_OBJ_DESCRIPTOR                     *CmObject
     )
   {
     UINT32  Index;

     if (CmObject == nullptr) {
       return EFI_INVALID_PARAMETER;
     }

     if (Token == CM_NULL_TOKEN) {
       *CmObject = CM_OBJ_DESCRIPTOR {
         CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
         static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO) * mProximityDomainInfo.size ()),
         mProximityDomainInfo.data (),
         static_cast<UINT32>(mProximityDomainInfo.size ())
       };

       return EFI_SUCCESS;
     }

     Index = (UINT32)Token - 1;
     if (Index >= mProximityDomainInfo.size ()) {
       return EFI_NOT_FOUND;
     }

     *CmObject = CM_OBJ_DESCRIPTOR {
       CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
       static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO)),
       &mProximityDomainInfo[Index],
       1
     };

     return EFI_SUCCESS;
   }

   EFI_STATUS
   GetMemProximityDomainAttrInfo (
     IN  CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL  *This,
     IN  CONST CM_OBJECT_ID                          CmObjectId,
     IN  CONST CM_OBJECT_TOKEN                       Token,
     IN  OUT   CM_OBJ_DESCRIPTOR                     *CmObject
     )
   {
     if (CmObject == nullptr) {
       return EFI_INVALID_PARAMETER;
     }

     *CmObject = CM_OBJ_DESCRIPTOR {
       CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryProximityDomainAttrInfo),
       static_cast<UINT32>(sizeof (CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO) * mMemProximityDomainAttrInfo.size ()),
       mMemProximityDomainAttrInfo.data (),
       static_cast<UINT32>(mMemProximityDomainAttrInfo.size ())
     };

     return EFI_SUCCESS;
   }

   EFI_STATUS
   GetMemLatBwInfo (
     IN  CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL  *This,
     IN  CONST CM_OBJECT_ID                          CmObjectId,
     IN  CONST CM_OBJECT_TOKEN                       Token,
     IN  OUT   CM_OBJ_DESCRIPTOR                     *CmObject
     )
   {
     if (CmObject == nullptr) {
       return EFI_INVALID_PARAMETER;
     }

     *CmObject = CM_OBJ_DESCRIPTOR {
       CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryLatBwInfo),
       static_cast<UINT32>(sizeof (CM_ARCH_COMMON_MEMORY_LAT_BW_INFO) * mMemLatBwInfo.size ()),
       mMemLatBwInfo.data (),
       static_cast<UINT32>(mMemLatBwInfo.size ())
     };

     return EFI_SUCCESS;
   }

   EFI_STATUS
   GetProximityDomainRelationInfo (
     IN  CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL  *This,
     IN  CONST CM_OBJECT_ID                          CmObjectId,
     IN  CONST CM_OBJECT_TOKEN                       Token,
     IN  OUT   CM_OBJ_DESCRIPTOR                     *CmObject
     )
   {
     if (CmObject == nullptr) {
       return EFI_INVALID_PARAMETER;
     }

     auto  it = mProximityDomainRelationInfo.find (Token);

     if (it == mProximityDomainRelationInfo.end ()) {
       return EFI_NOT_FOUND;
     }

     *CmObject = CM_OBJ_DESCRIPTOR {
       CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainRelationInfo),
       static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO) * it->second.size ()),
       it->second.data (),
       static_cast<UINT32>(it->second.size ())
     };

     return EFI_SUCCESS;
   }

   CM_STD_OBJ_ACPI_TABLE_INFO mAcpiTableInfo;
   std::vector<CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO> mProximityDomainInfo;
   std::vector<CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO> mMemProximityDomainAttrInfo;
   std::vector<CM_ARCH_COMMON_MEMORY_LAT_BW_INFO> mMemLatBwInfo;
   std::map<CM_OBJECT_TOKEN, std::vector<CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO> > mProximityDomainRelationInfo;
   EFI_ACPI_DESCRIPTION_HEADER *mTableUnderTest = nullptr;

   CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO mDefaultProximityDomains[10];

   CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO mDefaultMemProximity[2] = {
     {
       .Flags                    = 0,
       .InitiatorProximityDomain = 1,
       .MemoryProximityDomain    = 2
     },
     {
       .Flags                    = 1,
       .InitiatorProximityDomain = 3,
       .MemoryProximityDomain    = 4
     }
   };

   CM_ARCH_COMMON_MEMORY_LAT_BW_INFO mDefaultMemLatBw[2] = {
     {
       .Flags                 = 1,
       .DataType              = 3,
       .MinTransferSize       = 24,
       .EntryBaseUnit         = 2,
       .RelativeDistanceArray = 1
     },
     {
       .Flags                 = 1,
       .DataType              = 3,
       .MinTransferSize       = 24,
       .EntryBaseUnit         = 2,
       .RelativeDistanceArray = 2
     }
   };

   CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mDefaultMatrix1[4] = {
     { .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 100 },
     { .FirstDomainToken = 1, .SecondDomainToken = 4, .Relation = 200 },
     { .FirstDomainToken = 3, .SecondDomainToken = 2, .Relation = 300 },
     { .FirstDomainToken = 3, .SecondDomainToken = 4, .Relation = 400 }
   };

   CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mDefaultMatrix2[2] = {
     { .FirstDomainToken = 1, .SecondDomainToken = 5, .Relation = 1000 },
     { .FirstDomainToken = 1, .SecondDomainToken = 6, .Relation = 2000 },
   };

   // Invalid relation value, should be in UINT16 range
   CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mInvalidRelMatrix[2] = {
     { .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 301000 },
     { .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 302000 },
   };
 };

 STATIC
 constexpr UINT32
 GetSLLBISize (
   UINT32  InitiatorCount,
   UINT32  TargetCount
   )
 {
   return sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO) +
          InitiatorCount * sizeof (UINT32) +
          TargetCount * sizeof (UINT32) +
          InitiatorCount * TargetCount * sizeof (UINT16);
 }

 constexpr EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES  kExpectedMpda[2] = {
   {
     .Type   = 0,
     .Length = 40,
     .Flags  = {
       .InitiatorProximityDomainValid = 0
     },
     .InitiatorProximityDomain = 100,
     .MemoryProximityDomain    = 101,
   },
   {
     .Type   = 0,
     .Length = 40,
     .Flags  = {
       .InitiatorProximityDomainValid = 1
     },
     .InitiatorProximityDomain = 102,
     .MemoryProximityDomain    = 103
   }
 };

 constexpr EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO  kExpectedSllbiBase[2] = {
   {
     .Type   = 1,
     .Length = GetSLLBISize (2, 2),
     .Flags  = {
       .MemoryHierarchy = 1
     },
     .DataType                          = 3,
     .MinTransferSize                   = 24,
     .NumberOfInitiatorProximityDomains = 2,
     .NumberOfTargetProximityDomains    = 2,
     .EntryBaseUnit                     = 2
   },
   {
     .Type   = 1,
     .Length = GetSLLBISize (1, 2),
     .Flags  = {
       .MemoryHierarchy = 1
     },
     .DataType                          = 3,
     .MinTransferSize                   = 24,
     .NumberOfInitiatorProximityDomains = 1,
     .NumberOfTargetProximityDomains    = 2,
     .EntryBaseUnit                     = 2
   }
 };

 constexpr UINT32  kExpectedSllbiInitiators0[2] = {
   100, 102
 };

 constexpr UINT32  kExpectedSllbiInitiators1[1] = {
   100
 };

 constexpr UINT32  kExpectedSllbiTargets0[2] = {
   101, 103
 };

 constexpr UINT32  kExpectedSllbiTargets1[2] = {
   104, 105
 };

 constexpr UINT16  kExpectedSllbiMatrix0[4] = { 100, 200, 300, 400
 };

 constexpr UINT16  kExpectedSllbiMatrix1[2] = { 1000, 2000
 };

 TEST_F (HmatGeneratorTest, NoProximityDomainsTest) {
   SetupProximityDomainInfo (4);
   SetupMemLatBwInfo (mDefaultMemLatBw, 1);
   SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, mDefaultMatrix1, 4);
   EXPECT_EQ (
     gHmatGenerator->BuildAcpiTable (
                       gHmatGenerator,
                       &mAcpiTableInfo,
                       gConfigurationManagerProtocol,
                       &mTableUnderTest
                       ),
     EFI_SUCCESS
     );
   UINT32  expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
                          GetSLLBISize (2, 2);

   EXPECT_EQ (mTableUnderTest->Length, expectedSize);

   UINT8  *mTableUnderTestPtr = (UINT8 *)mTableUnderTest;

   ValidateSSLBI (
     &kExpectedSllbiBase[0],
     kExpectedSllbiInitiators0,
     kExpectedSllbiTargets0,
     kExpectedSllbiMatrix0,
     (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&mTableUnderTestPtr[40]
     );
 }

 TEST_F (HmatGeneratorTest, NoLatencyInfoTest) {
   SetupProximityDomainInfo (4);
   SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
   EXPECT_EQ (
     gHmatGenerator->BuildAcpiTable (
                       gHmatGenerator,
                       &mAcpiTableInfo,
                       gConfigurationManagerProtocol,
                       &mTableUnderTest
                       ),
     EFI_SUCCESS
     );
   UINT32  expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
                          2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);

   EXPECT_EQ (mTableUnderTest->Length, expectedSize);
   UINT8  *tableUnderTestPtr = (UINT8 *)mTableUnderTest;

   UINT32  Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER);

   ValidateMemProximityDomainAttrInfo (&kExpectedMpda[0], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

   Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
         sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
   ValidateMemProximityDomainAttrInfo (&kExpectedMpda[1], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);
 }

 TEST_F (HmatGeneratorTest, MismatchedMatrixSizeTest) {
   SetupProximityDomainInfo (4);
   SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
   SetupMemLatBwInfo (mDefaultMemLatBw, 1);
   SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, &mDefaultMatrix1[0], 3); // Should be 4
   EXPECT_EQ (
     gHmatGenerator->BuildAcpiTable (
                       gHmatGenerator,
                       &mAcpiTableInfo,
                       gConfigurationManagerProtocol,
                       &mTableUnderTest
                       ),
     EFI_INVALID_PARAMETER
     );
 }

 TEST_F (HmatGeneratorTest, InvalidRelationValueTest) {
   SetupProximityDomainInfo (4);
   SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
   SetupMemLatBwInfo (mDefaultMemLatBw, 1);
   SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, &mInvalidRelMatrix[0], 2);
   EXPECT_EQ (
     gHmatGenerator->BuildAcpiTable (
                       gHmatGenerator,
                       &mAcpiTableInfo,
                       gConfigurationManagerProtocol,
                       &mTableUnderTest
                       ),
     EFI_INVALID_PARAMETER
     );
 }

 TEST_F (HmatGeneratorTest, ValidTableTest) {
   SetupProximityDomainInfo (7);
   SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
   SetupMemLatBwInfo (mDefaultMemLatBw, 2);
   SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, mDefaultMatrix1, 4);
   SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)2, mDefaultMatrix2, 2);

   EXPECT_EQ (
     gHmatGenerator->BuildAcpiTable (
                       gHmatGenerator,
                       &mAcpiTableInfo,
                       gConfigurationManagerProtocol,
                       &mTableUnderTest
                       ),
     EFI_SUCCESS
     );

   EXPECT_NE (mTableUnderTest, nullptr);
   UINT32  expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
                          2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES) +
                          GetSLLBISize (2, 2) +
                          GetSLLBISize (2, 1);

   EXPECT_EQ (mTableUnderTest->Length, expectedSize);
   UINT8  *tableUnderTestPtr = (UINT8 *)mTableUnderTest;

   UINT32  Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER);

   ValidateMemProximityDomainAttrInfo (&kExpectedMpda[0], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

   Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
         sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
   ValidateMemProximityDomainAttrInfo (&kExpectedMpda[1], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

   Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
         2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
   ValidateSSLBI (
     &kExpectedSllbiBase[0],
     kExpectedSllbiInitiators0,
     kExpectedSllbiTargets0,
     kExpectedSllbiMatrix0,
     (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&tableUnderTestPtr[Idx]
     );

   Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
         2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES) +
         GetSLLBISize (2, 2);
   ValidateSSLBI (
     &kExpectedSllbiBase[1],
     kExpectedSllbiInitiators1,
     kExpectedSllbiTargets1,
     kExpectedSllbiMatrix1,
     (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&tableUnderTestPtr[Idx]
     );
 }

 int
 main (
   int   argc,
   char  *argv[]
   )
 {
   testing::InitGoogleTest (&argc, argv);
   return RUN_ALL_TESTS ();
 }
	/** @file
	Unit tests for HMAT Generator

	Copyright (c) 2026, Google LLC. All rights reserved. <BR>

	SPDX-License-Identifier: BSD-2-Clause-Patent
	**/

	#include "Base.h"
	#include <gtest/gtest.h>
	#include <gmock/gmock.h>
	#include <Library/GoogleTestLib.h>

	extern "C" {
	#include <Uefi.h>
	#include <Protocol/ConfigurationManagerProtocol.h>
	#include <Library/FunctionMockLib.h>
	#include <Library/BaseMemoryLib.h>
	#include <Library/DebugLib.h>
	#include <Library/MemoryAllocationLib.h>
	#include <Library/TableHelperLib.h>
	#include <Library/MetadataObjLib.h>
	#include <AcpiTableGenerator.h>
	#include <ConfigurationManagerObject.h>
	#include <ConfigurationManagerHelper.h>
	#include <StandardNameSpaceObjects.h>
	#include <IndustryStandard/Acpi64.h>
	#include "GoogleTest/Protocol/MockConfigurationManagerProtocol.h"
	#include "Library/Common/MetadataHandlerLib/MetadataHandler.h"

	EFI_STATUS
	EFIAPI
	AcpiHmatLibConstructor (
	IN EFI_HANDLE ImageHandle,
	IN EFI_SYSTEM_TABLE *SystemTable
	);

	EFI_STATUS
	EFIAPI
	AcpiHmatLibDestructor (
	IN EFI_HANDLE ImageHandle,
	IN EFI_SYSTEM_TABLE *SystemTable
	);

	// Global generator instance
	static ACPI_TABLE_GENERATOR *gHmatGenerator = NULL;

	static METADATA_ROOT_HANDLE mMetadataRoot;

	// C++ wrapper functions for C linkage functions
	EFI_STATUS
	RegisterAcpiTableGenerator (
	IN CONST ACPI_TABLE_GENERATOR *CONST TableGenerator
	)
	{
	if (TableGenerator == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	gHmatGenerator = const_cast<ACPI_TABLE_GENERATOR *>(TableGenerator);
	return EFI_SUCCESS;
	}

	EFI_STATUS
	DeregisterAcpiTableGenerator (
	IN CONST ACPI_TABLE_GENERATOR *CONST TableGenerator
	)
	{
	if (TableGenerator == NULL) {
	return EFI_INVALID_PARAMETER;
	}

	// Clear the stored generator
	gHmatGenerator = NULL;
	return EFI_SUCCESS;
	}

	METADATA_ROOT_HANDLE
	EFIAPI
	GetMetadataRoot (
	VOID
	)
	{
	return mMetadataRoot;
	}
	}

	using namespace testing;
	using ::testing::_;
	using ::testing::NiceMock;
	using ::testing::Return;
	using ::testing::DoAll;
	using ::testing::SetArgPointee;
	using ::testing::AtLeast;

	class HmatGeneratorTest : public ::testing::Test {
	protected:
	MockConfigurationManagerProtocol MockConfigMgrProtocol;
	CM_STD_OBJ_CONFIGURATION_MANAGER_INFO CfgMgrInfo = { 0 };

	void
	ValidateMemProximityDomainAttrInfo (
	const EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *Expected,
	const EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *Actual
	)
	{
	EXPECT_EQ (Actual->Type, Expected->Type);
	EXPECT_EQ (Actual->Length, sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES));
	EXPECT_EQ (Actual->Flags.InitiatorProximityDomainValid, Expected->Flags.InitiatorProximityDomainValid);
	EXPECT_EQ (Actual->InitiatorProximityDomain, Expected->InitiatorProximityDomain);
	EXPECT_EQ (Actual->MemoryProximityDomain, Expected->MemoryProximityDomain);
	}

	void
	ValidateSSLBI (
	const EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *ExpectedBase,
	const UINT32 *ExpectedInitiatorDomains,
	const UINT32 *ExpectedTargetDomains,
	const UINT16 *ExpectedLatencyMatrix,
	const EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *Actual
	)
	{
	EXPECT_EQ (Actual->Type, ExpectedBase->Type);
	EXPECT_EQ (Actual->Length, ExpectedBase->Length);
	EXPECT_EQ (Actual->Flags.AccessAttributes, ExpectedBase->Flags.AccessAttributes);
	EXPECT_EQ (Actual->Flags.MemoryHierarchy, ExpectedBase->Flags.MemoryHierarchy);
	EXPECT_EQ (Actual->DataType, ExpectedBase->DataType);
	EXPECT_EQ (Actual->NumberOfInitiatorProximityDomains, ExpectedBase->NumberOfInitiatorProximityDomains);
	EXPECT_EQ (Actual->NumberOfTargetProximityDomains, ExpectedBase->NumberOfTargetProximityDomains);
	EXPECT_EQ (Actual->EntryBaseUnit, ExpectedBase->EntryBaseUnit);

	UINT8 Ptr = (UINT8 )Actual;
	UINT32 ActualInitiatorDomains = (UINT32 )(Ptr + sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO));

	for (UINT32 i = 0; i < ExpectedBase->NumberOfInitiatorProximityDomains; i++) {
	EXPECT_EQ (ActualInitiatorDomains[i], ExpectedInitiatorDomains[i]);
	}

	UINT32 ActualTargetDomains = (UINT32 )(ActualInitiatorDomains + ExpectedBase->NumberOfInitiatorProximityDomains);

	for (UINT32 i = 0; i < ExpectedBase->NumberOfTargetProximityDomains; i++) {
	EXPECT_EQ (ActualTargetDomains[i], ExpectedTargetDomains[i]);
	}

	UINT16 ActualLatencyMatrix = (UINT16 )(ActualTargetDomains + ExpectedBase->NumberOfTargetProximityDomains);

	for (UINT32 i = 0; i < ExpectedBase->NumberOfInitiatorProximityDomains * ExpectedBase->NumberOfTargetProximityDomains; i++) {
	EXPECT_EQ (ActualLatencyMatrix[i], ExpectedLatencyMatrix[i]);
	}
	}

	void
	SetUp (
	) override
	{
	// Set up default behavior for GetObject
	ON_CALL (MockConfigMgrProtocol, GetObject (_, _, _, _))
	.WillByDefault (Return (EFI_NOT_FOUND));

	// Set up configuration manager info
	CfgMgrInfo.Revision = CREATE_REVISION (1, 0);
	CfgMgrInfo.OemId[0] = 'T';
	CfgMgrInfo.OemId[1] = 'E';
	CfgMgrInfo.OemId[2] = 'S';
	CfgMgrInfo.OemId[3] = 'T';
	CfgMgrInfo.OemId[4] = 'M';
	CfgMgrInfo.OemId[5] = 'E';

	EXPECT_CALL (MockConfigMgrProtocol, GetObject (_, CREATE_CM_STD_OBJECT_ID (EStdObjCfgMgrInfo), CM_NULL_TOKEN, _))
	.WillRepeatedly (
	DoAll (
	SetArgPointee<3>(
	CM_OBJ_DESCRIPTOR {
	CREATE_CM_STD_OBJECT_ID (EStdObjCfgMgrInfo),
	sizeof (CM_STD_OBJ_CONFIGURATION_MANAGER_INFO),
	&CfgMgrInfo,
	1
	}
	),
	Return (EFI_SUCCESS)
	)
	);

	EXPECT_CALL (
	MockConfigMgrProtocol,
	GetObject (
	_,
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
	_,
	_
	)
	)
	.WillRepeatedly (
	Invoke (WRAP_ACCESSOR (GetProximityDomainInfo))
	);

	EXPECT_CALL (
	MockConfigMgrProtocol,
	GetObject (
	_,
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryProximityDomainAttrInfo),
	CM_NULL_TOKEN,
	_
	)
	)
	.WillRepeatedly (
	Invoke (WRAP_ACCESSOR (GetMemProximityDomainAttrInfo))
	);

	EXPECT_CALL (
	MockConfigMgrProtocol,
	GetObject (
	_,
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryLatBwInfo),
	CM_NULL_TOKEN,
	_
	)
	)
	.WillRepeatedly (
	Invoke (WRAP_ACCESSOR (GetMemLatBwInfo))
	);

	EXPECT_CALL (
	MockConfigMgrProtocol,
	GetObject (
	_,
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainRelationInfo),
	_,
	_
	)
	)
	.WillRepeatedly (
	Invoke (WRAP_ACCESSOR (GetProximityDomainRelationInfo))
	);

	// Initialize the HMAT library with our mock protocol
	EXPECT_EQ (AcpiHmatLibConstructor (NULL, NULL), EFI_SUCCESS);

	// Setup common test data with proper initialization
	mAcpiTableInfo.TableGeneratorId = CREATE_STD_ACPI_TABLE_GEN_ID (EStdAcpiTableIdHmat);
	mAcpiTableInfo.AcpiTableSignature = EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_SIGNATURE;
	mAcpiTableInfo.AcpiTableRevision = EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_REVISION;

	MetadataInitializeHandle (&mMetadataRoot);
	}

	void
	TearDown (
	) override
	{
	if (mTableUnderTest != nullptr) {
	gHmatGenerator->FreeTableResources (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	);
	}

	// Clean up the HMAT library
	AcpiHmatLibDestructor (NULL, NULL);
	MetadataFreeHandle (mMetadataRoot);
	}

	void
	SetupProximityDomainInfo (
	UINT64 ProximityDomainInfoCount
	)
	{
	mProximityDomainInfo.resize (ProximityDomainInfoCount);
	for (UINT64 i = 0; i < ProximityDomainInfoCount; i++) {
	mProximityDomainInfo[i].GenerateDomainId = FALSE;
	mProximityDomainInfo[i].DomainId = 100 + (UINT32)i;
	}
	}

	void
	SetupMemProximityDomainAttrInfo (
	CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO *MemProximityDomainAttrInfo,
	UINT64 MemProximityDomainAttrInfoCount
	)
	{
	mMemProximityDomainAttrInfo.resize (MemProximityDomainAttrInfoCount);
	for (UINT64 i = 0; i < MemProximityDomainAttrInfoCount; i++) {
	mMemProximityDomainAttrInfo[i] = MemProximityDomainAttrInfo[i];
	}
	}

	void
	SetupMemLatBwInfo (
	CM_ARCH_COMMON_MEMORY_LAT_BW_INFO *MemLatBwInfo,
	UINT64 MemLatBwInfoCount
	)
	{
	mMemLatBwInfo.resize (MemLatBwInfoCount);
	for (UINT64 i = 0; i < MemLatBwInfoCount; i++) {
	mMemLatBwInfo[i] = MemLatBwInfo[i];
	}
	}

	void
	SetupProximityDomainRelationInfo (
	CM_OBJECT_TOKEN Token,
	CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO *Matrix,
	UINT64 MatrixCount
	)
	{
	mProximityDomainRelationInfo[Token].resize (MatrixCount);
	for (UINT64 i = 0; i < MatrixCount; i++) {
	mProximityDomainRelationInfo[Token][i] = Matrix[i];
	}
	}

	EFI_STATUS
	GetProximityDomainInfo (
	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *This,
	IN CONST CM_OBJECT_ID CmObjectId,
	IN CONST CM_OBJECT_TOKEN Token,
	IN OUT CM_OBJ_DESCRIPTOR *CmObject
	)
	{
	UINT32 Index;

	if (CmObject == nullptr) {
	return EFI_INVALID_PARAMETER;
	}

	if (Token == CM_NULL_TOKEN) {
	*CmObject = CM_OBJ_DESCRIPTOR {
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
	static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO) * mProximityDomainInfo.size ()),
	mProximityDomainInfo.data (),
	static_cast<UINT32>(mProximityDomainInfo.size ())
	};

	return EFI_SUCCESS;
	}

	Index = (UINT32)Token - 1;
	if (Index >= mProximityDomainInfo.size ()) {
	return EFI_NOT_FOUND;
	}

	*CmObject = CM_OBJ_DESCRIPTOR {
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainInfo),
	static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO)),
	&mProximityDomainInfo[Index],
	1
	};

	return EFI_SUCCESS;
	}

	EFI_STATUS
	GetMemProximityDomainAttrInfo (
	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *This,
	IN CONST CM_OBJECT_ID CmObjectId,
	IN CONST CM_OBJECT_TOKEN Token,
	IN OUT CM_OBJ_DESCRIPTOR *CmObject
	)
	{
	if (CmObject == nullptr) {
	return EFI_INVALID_PARAMETER;
	}

	*CmObject = CM_OBJ_DESCRIPTOR {
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryProximityDomainAttrInfo),
	static_cast<UINT32>(sizeof (CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO) * mMemProximityDomainAttrInfo.size ()),
	mMemProximityDomainAttrInfo.data (),
	static_cast<UINT32>(mMemProximityDomainAttrInfo.size ())
	};

	return EFI_SUCCESS;
	}

	EFI_STATUS
	GetMemLatBwInfo (
	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *This,
	IN CONST CM_OBJECT_ID CmObjectId,
	IN CONST CM_OBJECT_TOKEN Token,
	IN OUT CM_OBJ_DESCRIPTOR *CmObject
	)
	{
	if (CmObject == nullptr) {
	return EFI_INVALID_PARAMETER;
	}

	*CmObject = CM_OBJ_DESCRIPTOR {
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjMemoryLatBwInfo),
	static_cast<UINT32>(sizeof (CM_ARCH_COMMON_MEMORY_LAT_BW_INFO) * mMemLatBwInfo.size ()),
	mMemLatBwInfo.data (),
	static_cast<UINT32>(mMemLatBwInfo.size ())
	};

	return EFI_SUCCESS;
	}

	EFI_STATUS
	GetProximityDomainRelationInfo (
	IN CONST EDKII_CONFIGURATION_MANAGER_PROTOCOL *This,
	IN CONST CM_OBJECT_ID CmObjectId,
	IN CONST CM_OBJECT_TOKEN Token,
	IN OUT CM_OBJ_DESCRIPTOR *CmObject
	)
	{
	if (CmObject == nullptr) {
	return EFI_INVALID_PARAMETER;
	}

	auto it = mProximityDomainRelationInfo.find (Token);

	if (it == mProximityDomainRelationInfo.end ()) {
	return EFI_NOT_FOUND;
	}

	*CmObject = CM_OBJ_DESCRIPTOR {
	CREATE_CM_ARCH_COMMON_OBJECT_ID (EArchCommonObjProximityDomainRelationInfo),
	static_cast<UINT32>(sizeof (CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO) * it->second.size ()),
	it->second.data (),
	static_cast<UINT32>(it->second.size ())
	};

	return EFI_SUCCESS;
	}

	CM_STD_OBJ_ACPI_TABLE_INFO mAcpiTableInfo;
	std::vector<CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO> mProximityDomainInfo;
	std::vector<CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO> mMemProximityDomainAttrInfo;
	std::vector<CM_ARCH_COMMON_MEMORY_LAT_BW_INFO> mMemLatBwInfo;
	std::map<CM_OBJECT_TOKEN, std::vector<CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO> > mProximityDomainRelationInfo;
	EFI_ACPI_DESCRIPTION_HEADER *mTableUnderTest = nullptr;

	CM_ARCH_COMMON_PROXIMITY_DOMAIN_INFO mDefaultProximityDomains[10];

	CM_ARCH_COMMON_MEMORY_PROXIMITY_DOMAIN_ATTR_INFO mDefaultMemProximity[2] = {
	{
	.Flags = 0,
	.InitiatorProximityDomain = 1,
	.MemoryProximityDomain = 2
	},
	{
	.Flags = 1,
	.InitiatorProximityDomain = 3,
	.MemoryProximityDomain = 4
	}
	};

	CM_ARCH_COMMON_MEMORY_LAT_BW_INFO mDefaultMemLatBw[2] = {
	{
	.Flags = 1,
	.DataType = 3,
	.MinTransferSize = 24,
	.EntryBaseUnit = 2,
	.RelativeDistanceArray = 1
	},
	{
	.Flags = 1,
	.DataType = 3,
	.MinTransferSize = 24,
	.EntryBaseUnit = 2,
	.RelativeDistanceArray = 2
	}
	};

	CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mDefaultMatrix1[4] = {
	{ .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 100 },
	{ .FirstDomainToken = 1, .SecondDomainToken = 4, .Relation = 200 },
	{ .FirstDomainToken = 3, .SecondDomainToken = 2, .Relation = 300 },
	{ .FirstDomainToken = 3, .SecondDomainToken = 4, .Relation = 400 }
	};

	CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mDefaultMatrix2[2] = {
	{ .FirstDomainToken = 1, .SecondDomainToken = 5, .Relation = 1000 },
	{ .FirstDomainToken = 1, .SecondDomainToken = 6, .Relation = 2000 },
	};

	// Invalid relation value, should be in UINT16 range
	CM_ARCH_COMMON_PROXIMITY_DOMAIN_RELATION_INFO mInvalidRelMatrix[2] = {
	{ .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 301000 },
	{ .FirstDomainToken = 1, .SecondDomainToken = 2, .Relation = 302000 },
	};
	};

	STATIC
	constexpr UINT32
	GetSLLBISize (
	UINT32 InitiatorCount,
	UINT32 TargetCount
	)
	{
	return sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO) +
	InitiatorCount * sizeof (UINT32) +
	TargetCount * sizeof (UINT32) +
	InitiatorCount * TargetCount * sizeof (UINT16);
	}

	constexpr EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES kExpectedMpda[2] = {
	{
	.Type = 0,
	.Length = 40,
	.Flags = {
	.InitiatorProximityDomainValid = 0
	},
	.InitiatorProximityDomain = 100,
	.MemoryProximityDomain = 101,
	},
	{
	.Type = 0,
	.Length = 40,
	.Flags = {
	.InitiatorProximityDomainValid = 1
	},
	.InitiatorProximityDomain = 102,
	.MemoryProximityDomain = 103
	}
	};

	constexpr EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO kExpectedSllbiBase[2] = {
	{
	.Type = 1,
	.Length = GetSLLBISize (2, 2),
	.Flags = {
	.MemoryHierarchy = 1
	},
	.DataType = 3,
	.MinTransferSize = 24,
	.NumberOfInitiatorProximityDomains = 2,
	.NumberOfTargetProximityDomains = 2,
	.EntryBaseUnit = 2
	},
	{
	.Type = 1,
	.Length = GetSLLBISize (1, 2),
	.Flags = {
	.MemoryHierarchy = 1
	},
	.DataType = 3,
	.MinTransferSize = 24,
	.NumberOfInitiatorProximityDomains = 1,
	.NumberOfTargetProximityDomains = 2,
	.EntryBaseUnit = 2
	}
	};

	constexpr UINT32 kExpectedSllbiInitiators0[2] = {
	100, 102
	};

	constexpr UINT32 kExpectedSllbiInitiators1[1] = {
	100
	};

	constexpr UINT32 kExpectedSllbiTargets0[2] = {
	101, 103
	};

	constexpr UINT32 kExpectedSllbiTargets1[2] = {
	104, 105
	};

	constexpr UINT16 kExpectedSllbiMatrix0[4] = { 100, 200, 300, 400
	};

	constexpr UINT16 kExpectedSllbiMatrix1[2] = { 1000, 2000
	};

	TEST_F (HmatGeneratorTest, NoProximityDomainsTest) {
	SetupProximityDomainInfo (4);
	SetupMemLatBwInfo (mDefaultMemLatBw, 1);
	SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, mDefaultMatrix1, 4);
	EXPECT_EQ (
	gHmatGenerator->BuildAcpiTable (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	),
	EFI_SUCCESS
	);
	UINT32 expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	GetSLLBISize (2, 2);

	EXPECT_EQ (mTableUnderTest->Length, expectedSize);

	UINT8 mTableUnderTestPtr = (UINT8 )mTableUnderTest;

	ValidateSSLBI (
	&kExpectedSllbiBase[0],
	kExpectedSllbiInitiators0,
	kExpectedSllbiTargets0,
	kExpectedSllbiMatrix0,
	(EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&mTableUnderTestPtr[40]
	);
	}

	TEST_F (HmatGeneratorTest, NoLatencyInfoTest) {
	SetupProximityDomainInfo (4);
	SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
	EXPECT_EQ (
	gHmatGenerator->BuildAcpiTable (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	),
	EFI_SUCCESS
	);
	UINT32 expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);

	EXPECT_EQ (mTableUnderTest->Length, expectedSize);
	UINT8 tableUnderTestPtr = (UINT8 )mTableUnderTest;

	UINT32 Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER);

	ValidateMemProximityDomainAttrInfo (&kExpectedMpda[0], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

	Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
	ValidateMemProximityDomainAttrInfo (&kExpectedMpda[1], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);
	}

	TEST_F (HmatGeneratorTest, MismatchedMatrixSizeTest) {
	SetupProximityDomainInfo (4);
	SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
	SetupMemLatBwInfo (mDefaultMemLatBw, 1);
	SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, &mDefaultMatrix1[0], 3); // Should be 4
	EXPECT_EQ (
	gHmatGenerator->BuildAcpiTable (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	),
	EFI_INVALID_PARAMETER
	);
	}

	TEST_F (HmatGeneratorTest, InvalidRelationValueTest) {
	SetupProximityDomainInfo (4);
	SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
	SetupMemLatBwInfo (mDefaultMemLatBw, 1);
	SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, &mInvalidRelMatrix[0], 2);
	EXPECT_EQ (
	gHmatGenerator->BuildAcpiTable (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	),
	EFI_INVALID_PARAMETER
	);
	}

	TEST_F (HmatGeneratorTest, ValidTableTest) {
	SetupProximityDomainInfo (7);
	SetupMemProximityDomainAttrInfo (mDefaultMemProximity, 2);
	SetupMemLatBwInfo (mDefaultMemLatBw, 2);
	SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)1, mDefaultMatrix1, 4);
	SetupProximityDomainRelationInfo ((CM_OBJECT_TOKEN)2, mDefaultMatrix2, 2);

	EXPECT_EQ (
	gHmatGenerator->BuildAcpiTable (
	gHmatGenerator,
	&mAcpiTableInfo,
	gConfigurationManagerProtocol,
	&mTableUnderTest
	),
	EFI_SUCCESS
	);

	EXPECT_NE (mTableUnderTest, nullptr);
	UINT32 expectedSize = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES) +
	GetSLLBISize (2, 2) +
	GetSLLBISize (2, 1);

	EXPECT_EQ (mTableUnderTest->Length, expectedSize);
	UINT8 tableUnderTestPtr = (UINT8 )mTableUnderTest;

	UINT32 Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER);

	ValidateMemProximityDomainAttrInfo (&kExpectedMpda[0], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

	Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
	ValidateMemProximityDomainAttrInfo (&kExpectedMpda[1], (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES *)&tableUnderTestPtr[Idx]);

	Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES);
	ValidateSSLBI (
	&kExpectedSllbiBase[0],
	kExpectedSllbiInitiators0,
	kExpectedSllbiTargets0,
	kExpectedSllbiMatrix0,
	(EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&tableUnderTestPtr[Idx]
	);

	Idx = sizeof (EFI_ACPI_6_4_HETEROGENEOUS_MEMORY_ATTRIBUTE_TABLE_HEADER) +
	2 * sizeof (EFI_ACPI_6_4_HMAT_STRUCTURE_MEMORY_PROXIMITY_DOMAIN_ATTRIBUTES) +
	GetSLLBISize (2, 2);
	ValidateSSLBI (
	&kExpectedSllbiBase[1],
	kExpectedSllbiInitiators1,
	kExpectedSllbiTargets1,
	kExpectedSllbiMatrix1,
	(EFI_ACPI_6_4_HMAT_STRUCTURE_SYSTEM_LOCALITY_LATENCY_AND_BANDWIDTH_INFO *)&tableUnderTestPtr[Idx]
	);
	}

	int
	main (
	int argc,
	char *argv[]
	)
	{
	testing::InitGoogleTest (&argc, argv);
	return RUN_ALL_TESTS ();
	}