/*==============================================================================
Copyright(c) 2017 Intel Corporation

Permission is hereby granted, free of charge, to any person obtaining a
copy of this software and associated documentation files(the "Software"),
to deal in the Software without restriction, including without limitation
the rights to use, copy, modify, merge, publish, distribute, sublicense,
and / or sell copies of the Software, and to permit persons to whom the
Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
============================================================================*/

#pragma once

#include "GmmCommonULT.h"

//===========================================================================
// typedef:
//      TEST_RESOURCE_TYPE_ENUM
//
// Description:
//     Decribes Resource types to test
//     when editing/adding existing/new enum, make sure to update corresponding
//     string array CTestResource::TestResourceTypeStr[].
//----------------------------------------------------------------------------
typedef enum TEST_RESOURCE_TYPE_ENUM
{
    TEST_RESOURCE_1D,
    TEST_RESOURCE_2D,
    TEST_RESOURCE_3D,
    TEST_RESOURCE_CUBE,
    TEST_RESOURCE_BUFFER,
    TEST_RESOURCE_MAX
}TEST_RESOURCE_TYPE;

//===========================================================================
// typedef:
//      TEST_RESOURCE_TYPE_ENUM
//
// Description:
//     Decribes Resource Tile Types to test .
//     when editing/adding existing/new enum, make sure to update corresponding
//     string array CTestResource::TestTileTypeStr[].
//----------------------------------------------------------------------------
typedef enum TEST_TILE_TYPE_ENUM
{
    TEST_LINEAR,
    TEST_TILEX,
    TEST_TILEY,
    TEST_TILEYS,
    TEST_TILEYF,
    TEST_TILEY_MAX = TEST_TILEYF,
    TEST_TILE4,
    TEST_TILE64,
    TEST_TILE_MAX
}TEST_TILE_TYPE;


//===========================================================================
// typedef:
//      TEST_BPP_ENUM
//
// Description:
//     Decribes BPP to test - 8, 16, 32, 64, 128 (Ignore 24/96 until need arises)
//     when editing/adding existing/new enum, make sure to update corresponding
//     string array CTestResource::TestBppStr[].
//----------------------------------------------------------------------------
typedef enum TEST_BPP_ENUM
{
    TEST_BPP_8,
    TEST_BPP_16,
    TEST_BPP_32,
    TEST_BPP_64,
    TEST_BPP_128,
    TEST_BPP_MAX
}TEST_BPP;

typedef enum TEST_MSAA_Samples
{
    MSAA_None,
    MSAA_2x,
    MSAA_4x,
    MSAA_8x,
    MSAA_16x,
    TEST_MSAA_MAX = MSAA_16x        //Should be equal to last MSAA type
} TEST_MSAA;

//===========================================================================
// GmmLib ULT macros for size alignment. Compitable with 64-bit numbers.
//---------------------------------------------------------------------------
#define GMM_ULT_ALIGN(x, a)          (((x) + ((a) - 1)) - (((x) + ((a) - 1)) & ((a) - 1))) // Alt implementation with bitwise not (~) has issue with uint32 align used with 64-bit value, since ~'ed value will remain 32-bit.
#define GMM_ULT_ALIGN_FLOOR(x, a)    ((x) - ((x) & ((a) - 1)))
#define GMM_ULT_MAX(a, b)            ((a) > (b)) ? (a) : (b)
#define GMM_ULT_MIN(a,b)             (((a) < (b)) ? (a) : (b))
#define GMM_ULT_ALIGN_NP2(x, a)      (((a) > 0) ? ((x) + (((a) - 1) - (((x) + ((a) - 1)) % (a)))) : (x))  //Next power of 2
#define GMM_ULT_MAX_MIPMAP           15
#define GMM_ULT_MAX_MIPTAIL_SLOTS    15
//////////////////////////////////////////////////////////////////////////
// typdef:
//     TEST_MIPTAIL_SLOT_OFFSET_REC
//
// Description:
//     Structure to hold the offset of the mip resources for unit level testing
//////////////////////////////////////////////////////////////////////////
typedef struct TEST_MIPTAIL_SLOT_OFFSET_REC
{
    uint32_t X;
    uint32_t Y;
    uint32_t Z;
}TEST_MIPTAIL_SLOT_OFFSET;


/////////////////////////////////////////////////////////////////////////
/// Fixture class for Resource. - This is Resource Test Case to test
/// all generic resource types, tile types, bpp and special allocations.
/// Contains Base implementation and inherits CommonULT class
/////////////////////////////////////////////////////////////////////////
class CTestResource : public CommonULT
{
protected:

    /////////////////////////////////////////////////////////////////////////////////////
    /// Returns GMM format for given test BPP input.
    ///
    /// @param[in]  Bpp: test Bpp value
    ///
    /// @return     ::GMM_RESOURCE_FORMAT
    /////////////////////////////////////////////////////////////////////////////////////
    GMM_RESOURCE_FORMAT SetResourceFormat(TEST_BPP Bpp)
    {
        switch (Bpp)
        {
        case TEST_BPP_8:
            return GMM_FORMAT_GENERIC_8BIT;
        case TEST_BPP_16:
            return GMM_FORMAT_GENERIC_16BIT;
        case TEST_BPP_32:
            return GMM_FORMAT_GENERIC_32BIT;
        case TEST_BPP_64:
            return GMM_FORMAT_GENERIC_64BIT;
        case TEST_BPP_128:
            return GMM_FORMAT_GENERIC_128BIT;
        default:
            break;
        }

        return GMM_FORMAT_INVALID;
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Returns Bpp (bytes per pixel) for a given bpp (bits per pixel) enum.
    ///
    /// @param[in]  bpp: test bpp value
    ///
    /// @return     Bytes per pixel
    /////////////////////////////////////////////////////////////////////////////////////
    uint32_t GetBppValue(TEST_BPP bpp)
    {
        uint32_t Bpp = 0;
        switch (bpp)
        {
        case TEST_BPP_8:
            Bpp = 8;
            break;
        case TEST_BPP_16:
            Bpp = 16;
            break;
        case TEST_BPP_32:
            Bpp = 32;
            break;
        case TEST_BPP_64:
            Bpp = 64;
            break;
        case TEST_BPP_128:
            Bpp = 128;
            break;
        default:
            break;
        }

        return Bpp >> 3;
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Set the tile flag in Gmm ResCreate Params
    ///
    /// @param[in]  Parms: Gmm Rescreate params
    /// @param[in]  Tile: Tile Type
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void SetTileFlag(GMM_RESCREATE_PARAMS &Params, TEST_TILE_TYPE Tile)
    {
        switch (Tile)
        {
            case TEST_LINEAR:
                Params.Flags.Info.Linear = 1;
                break;
            case TEST_TILEX:
                Params.Flags.Info.TiledX = 1;
                break;
            case TEST_TILEY:
	            if (pGfxAdapterInfo->SkuTable.FtrTileY)
	            {
	                Params.Flags.Info.TiledY = 1;
	            }
	            else
	            {
	                Params.Flags.Info.Tile4 = 1;
	            }
	            break;
        case TEST_TILEYF:
            Params.Flags.Info.TiledY  = 1;
            Params.Flags.Info.TiledYf = 1;
            break;
        case TEST_TILEYS:
            if (pGfxAdapterInfo->SkuTable.FtrTileY)
            {
                Params.Flags.Info.TiledY  = 1;
                Params.Flags.Info.TiledYs = 1;
            }
            else
            {
                Params.Flags.Info.Tile64 = 1;
            }
            break;
        default:
            break;
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Set the tile flag in Gmm Custom ResCreate Params
    ///
    /// @param[in]  Parms: Gmm Rescreate params
    /// @param[in]  Tile: Tile Type
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void SetTileFlag_Custom(GMM_RESCREATE_CUSTOM_PARAMS& Params, TEST_TILE_TYPE Tile)
    {
        switch (Tile)
        {
        case TEST_LINEAR:
            Params.Flags.Info.Linear = 1;
            break;
        case TEST_TILEX:
            Params.Flags.Info.TiledX = 1;
            break;
        case TEST_TILEY:
            if (pGfxAdapterInfo->SkuTable.FtrTileY)
            {
                Params.Flags.Info.TiledY = 1;
            }
            else
            {
                Params.Flags.Info.Tile4 = 1;
            }
            break;
        case TEST_TILEYF:
            Params.Flags.Info.TiledY = 1;
            Params.Flags.Info.TiledYf = 1;
            break;
        case TEST_TILEYS:
            if (pGfxAdapterInfo->SkuTable.FtrTileY)
            {
                Params.Flags.Info.TiledY  = 1;
                Params.Flags.Info.TiledYs = 1;
            }
            else
            {
                Params.Flags.Info.Tile64 = 1;
            }
            break;
        default:
            break;
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Sets Resource Type in GmmParams
    ///
    /// @param[in]  Params: GmmParams
    /// @param[in]  ResType: Resource type
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void SetResType(GMM_RESCREATE_PARAMS& Params, TEST_RESOURCE_TYPE ResType)
    {
        Params.Type = static_cast<GMM_RESOURCE_TYPE>((ResType == TEST_RESOURCE_BUFFER) ? ResType + 2 : ResType + 1);
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Sets RenderTarget or Depth Gpu Flags in GmmParams
    ///
    /// @param[in]  Params: GmmParams
    /// @param[in]  IsRT:  true for RT, false for Depth
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void SetResGpuFlags(GMM_RESCREATE_PARAMS& Params, bool IsRT)
    {
        if (IsRT)
        {
            Params.Flags.Gpu.Depth = 0;
            Params.Flags.Gpu.RenderTarget = 1;
        }
        else
        {
            Params.Flags.Gpu.Depth = 1;
            Params.Flags.Gpu.RenderTarget = 0;
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Sets ArraySize in GmmParams
    ///
    /// @param[in]  Params: GmmParams
    /// @param[in]  Size: Array Size
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void SetResArraySize(GMM_RESCREATE_PARAMS& Params, int Size)
    {
        Params.ArraySize = Size;
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Get the Tile dimension and H/V Align for MSS and MCS surfaces
    ///
    /// @param[in]  Bpp: bits per pixel
    /// @param[in]  isRT: Request is for RT or Depth MSS
    /// @param[in]  Tiling: Tile Type
    /// @param[in]  MSAA: Num of Samples
    /// @param[out] HAlign: H Align for MSS
    /// @param[out] VAlign: V Align for MSS
    /// @param[out] TileDimX: Tile Width for given Tile, Resource, bpp
    /// @param[out] TileDimY: Tile Height for given Tile, Resource, bpp
    /// @param[out] MCSHAlign: H Align for MCS
    /// @param[out] MCSVAlign: V Align for MCS
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void GetAlignmentAndTileDimensionsForMSAA(TEST_BPP Bpp, bool isRT, TEST_TILE_TYPE Tiling, TEST_MSAA MSAA,
        uint32_t& TileDimX, uint32_t& TileDimY, uint32_t& HAlign, uint32_t& VAlign,
        uint32_t& ExpectedMCSBpp, uint32_t &MCSHAlign, uint32_t &MCSVAlign)
    {
        const uint32_t MSSTileSize[TEST_TILE_MAX][TEST_BPP_MAX][2] = {
        {{64, 1}, {64, 1}, {64, 1}, {64, 1}, {64, 1}},                //Linear - no Tile Size, but min PitchAlign = 64
        {{512, 8}, {512, 8}, {512, 8}, {512, 8}, {512, 8}},           //TileX
        {{128, 32}, {128, 32}, {128, 32}, {128, 32}, {128, 32}},      //TileY
        {{256, 256}, {512, 128}, {512, 128}, {1024, 64}, {1024, 64}}, //TileYs
        {{64, 64}, {128, 32}, {128, 32}, {256, 16}, {256, 16}},       //TileYf
        {{128, 32}, {128, 32}, {128, 32}, {128, 32}, {128, 32}},      //Tile4
        {{256, 256}, {512, 128}, {512, 128}, {1024, 64}, {1024, 64}}  //Tile64
		};
        uint32_t WMul = 1, HMul = 1;

        HAlign = 16;                              // RT H/VAlign
        VAlign = 4;

        if (!isRT)
        {
            HAlign = (Bpp == TEST_BPP_16) ? 8 : 4;     //Depth 16bit = 8x4, ow 4x4
            VAlign = 4;
            MCSHAlign = 4;                            //MCS uses base H/VAlign for 8bpp
        }

        uint32_t Tile[2] = {MSSTileSize[Tiling][Bpp][0], MSSTileSize[Tiling][Bpp][1]};
        if (Tiling == TEST_TILEYS || Tiling == TEST_TILEYF || Tiling == TEST_TILE64)
        {
            GetInterleaveMSSPattern(MSAA, WMul, HMul, isRT, Bpp);

            //Std Tiling interleaves MSAA into 1x, decreasing std Tile size for MSAA'd sample
            //Std Tiling types should have std size alignment always
            Tile[0] = HAlign = (isRT) ? (MSSTileSize[Tiling][Bpp][0] / WMul) : MSSTileSize[Tiling][Bpp][0];
            Tile[1] = VAlign = (isRT) ? (MSSTileSize[Tiling][Bpp][1] / HMul) : MSSTileSize[Tiling][Bpp][1];

            HAlign /= pow(2.0, Bpp);      //Unit alignment in pixels
        }
        TileDimX = Tile[0];
        TileDimY = Tile[1];

        ExpectedMCSBpp = (MSAA == MSAA_2x || MSAA == MSAA_4x) ? 1 :
            (MSAA == MSAA_8x) ? 4 : 8;

        uint32_t ExpectedMcsBppIdx = log2(ExpectedMCSBpp);

        MCSHAlign = isRT ? HAlign : MCSHAlign;              //MCS uses base H/V ALign for 8bpp
        MCSVAlign = VAlign;

        MCSHAlign = (isRT && (Tiling == TEST_TILEYS || Tiling == TEST_TILEYF)) ?
                             MSSTileSize[Tiling][ExpectedMcsBppIdx][0] / (WMul * ExpectedMCSBpp) :         //Std Tile dim in pixels
                            (Tiling == TEST_TILEYS || Tiling == TEST_TILEYF) ?
                             MSSTileSize[Tiling][ExpectedMcsBppIdx][0] / ExpectedMCSBpp : MCSHAlign;       //For legacy tile, MCS alignment is base (RT or Depth) alignment
        MCSVAlign = (isRT && (Tiling == TEST_TILEYS || Tiling == TEST_TILEYF)) ? MSSTileSize[Tiling][ExpectedMcsBppIdx][1] / HMul :
                            (Tiling == TEST_TILEYS || Tiling == TEST_TILEYF) ? MSSTileSize[Tiling][ExpectedMcsBppIdx][1] : MCSVAlign;
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Get the interleave pattern for given Num Samples
    ///
    /// @param[in]  MSAA: Num of Samples
    /// @param[in]  IsRT: !RT means Depth resource
    /// @param[out] WidthMultiplier: Number of samples arranged side-by-side
    /// @param[out] HeightMultiplier: Number of samples arranged top-bottom
    ///
    /////////////////////////////////////////////////////////////////////////////////////
    void GetInterleaveMSSPattern(TEST_MSAA MSAA, uint32_t &WidthMultiplier, uint32_t &HeightMultiplier, bool IsRT, TEST_BPP Bpp)
    {
        WidthMultiplier = 1; HeightMultiplier = 1;

        switch (MSAA)
        {
        case MSAA_2x:
	            if (IsRT && pGfxAdapterInfo->SkuTable.FtrXe2PlusTiling && (Bpp == TEST_BPP_128))
	            {
	                HeightMultiplier = 2;
	            }
	            else
	            {
	                WidthMultiplier = 2;
	            }
                break;
            case MSAA_4x:
                WidthMultiplier  = 2;
                HeightMultiplier = 2;
                break;
            case MSAA_8x:
                WidthMultiplier  = 4;
                HeightMultiplier = 2;
	            if (IsRT && pGfxAdapterInfo->SkuTable.FtrXe2PlusTiling && ((Bpp == TEST_BPP_8) || (Bpp == TEST_BPP_32)))
	            {
	                WidthMultiplier  = 2;
	                HeightMultiplier = 4;
	            }
	            else if (IsRT && !pGfxAdapterInfo->SkuTable.FtrTileY && !pGfxAdapterInfo->SkuTable.FtrXe2PlusTiling)
                {
                    WidthMultiplier  = 2;
                    HeightMultiplier = 2;
                }
                break;
            case MSAA_16x:
                WidthMultiplier  = 4;
                HeightMultiplier = 4;
	            if (IsRT && pGfxAdapterInfo->SkuTable.FtrXe2PlusTiling && (Bpp == TEST_BPP_64))
	            {
	                WidthMultiplier  = 8;
	                HeightMultiplier = 2;
	            }
	            else if (IsRT && !pGfxAdapterInfo->SkuTable.FtrTileY && !pGfxAdapterInfo->SkuTable.FtrXe2PlusTiling)
                {
                    WidthMultiplier  = 2;
                    HeightMultiplier = 2;
                }
                break;
            default:
                break;

        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if HAlign matches the expected value.  Fails test if value doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceHAlign(GMM_RESOURCE_INFO *ResourceInfo, uint32_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetHAlign());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if HAlign matches the expected value.  Fails test if value doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceVAlign(GMM_RESOURCE_INFO *ResourceInfo, uint32_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetVAlign());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if Pitch (in bytes) matches the expected value.  Fails test if value
    /// doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourcePitch(GMM_RESOURCE_INFO *ResourceInfo, uint32_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetRenderPitch());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if Pitch in tiles matches the expected value.  Fails test if value
    /// doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourcePitchInTiles(GMM_RESOURCE_INFO *ResourceInfo, uint32_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetRenderPitchTiles());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if Size matches the expected value.  Fails test if value doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceSize(GMM_RESOURCE_INFO *ResourceInfo, uint64_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetSizeMainSurface());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if AuxCCSize matches the expected value.  Fails test if value doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceAuxCCSize(GMM_RESOURCE_INFO *ResourceInfo, uint64_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetSizeAuxSurface(GMM_AUX_CC));
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if QPitch matches the expected value.  Fails test if value doesn't match
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceQPitch(GMM_RESOURCE_INFO *ResourceInfo, uint64_t ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(ExpectedValue, ResourceInfo->GetQPitch());
        }
    }

    /////////////////////////////////////////////////////////////////////////////////////
    /// Verifies if Tile4 info flag is set or not.  Fails test if Tile4 flag is not set
    ///
    /// @param[in]  ResourceInfo: ResourceInfo returned by GmmLib
    /// @param[in]  ExpectedValue: expected value to check against
    /////////////////////////////////////////////////////////////////////////////////////
    template <bool Verify>
    void VerifyResourceTile4(GMM_RESOURCE_INFO *ResourceInfo, bool ExpectedValue)
    {
        if(Verify)
        {
            EXPECT_EQ(true, (GMM_IS_4KB_TILE(ResourceInfo->GetResFlags())));
        }
    }

public:
    CTestResource();
    ~CTestResource();

    static void SetUpTestCase();
    static void TearDownTestCase();

};


/////////////////////////////////////////////////////////////////////////
/// Fixture class for Resources targeted for CpuBlt. This is CpuBlt resource
/// test case. Inherits CTestResource class.
/// @see      CTestResource class
/////////////////////////////////////////////////////////////////////////
class CTestCpuBltResource : public CTestResource
{
public:
    CTestCpuBltResource();
    ~CTestCpuBltResource();

    static void SetUpTestCase();
    static void TearDownTestCase();

};

/////////////////////////////////////////////////////////////////////////
/// Helper function - builds list of input tuples
///
/// @param[in/out]  List: vector of tuple<int,int,int,bool,int,int>
/// @param[in]  maxTestDimension: Number of elements in TestDimensions[]
/// @param[in]  TestArray: Number fo elements in TestArraySize
///
/// @return   Number of tuples in the list
/// @see      GmmGen9ResourceULT.cpp
/////////////////////////////////////////////////////////////////////////
int BuildInputIterator(std::vector<std::tuple<int, int, int, bool, int, int>> &List, int maxTestDimension, int TestArray, bool XEHPPlus);