From: "Eric Jin" <eric.jin@intel.com>
To: devel@edk2.groups.io
Cc: shrishail patil <shrishail.patil@microchip.com>,
Supreeth Venkatesh <supreeth.venkatesh@arm.com>
Subject: [edk2-test][Patch 1/3] uefi-sct/SctPkg: Add HiiConfigAccess test source to IHVSCT
Date: Thu, 12 Sep 2019 11:02:52 +0800 [thread overview]
Message-ID: <20190912030252.14420-1-eric.jin@intel.com> (raw)
From: shrishail patil <shrishail.patil@microchip.com>
REF: https://bugzilla.tianocore.org/show_bug.cgi?id=2187
Adding HiiConfigAccess Protocol to IHVSCT.
This patch contains source code which is copied from
UEFISCT and added into IHVSCT.
Cc: Supreeth Venkatesh <supreeth.venkatesh@arm.com>
Cc: Eric Jin <eric.jin@intel.com>
Signed-off-by: shrishail patil <shrishail.patil@microchip.com>
---
.../BlackBoxTest/IhvHIIConfigAccessBBTest.inf | 56 ++
.../HIIConfigAccess/BlackBoxTest/Guid.h | 82 +++
.../BlackBoxTest/HIIConfigAccessBBTestMain.h | 145 ++++
.../HIIConfigAccess/BlackBoxTest/Guid.c | 50 ++
.../HIIConfigAccessBBTestConformance.c | 619 +++++++++++++++++
.../HIIConfigAccessBBTestFunction.c | 451 +++++++++++++
.../BlackBoxTest/HIIConfigAccessBBTestMain.c | 621 ++++++++++++++++++
7 files changed, 2024 insertions(+)
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.h
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.c
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestFunction.c
create mode 100644 uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.c
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf
new file mode 100644
index 000000000000..81252d100841
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf
@@ -0,0 +1,56 @@
+## @file
+#
+# Copyright 2006 - 2012 Unified EFI, Inc.<BR>
+# Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
+# Copyright (c) 2019, ARM Ltd. All rights reserved.<BR>
+# Copyright (c) 2019,Microchip Technology Inc.<BR>
+#
+# This program and the accompanying materials
+# are licensed and made available under the terms and conditions of the BSD License
+# which accompanies this distribution. The full text of the license may be found at
+# http://opensource.org/licenses/bsd-license.php
+#
+# THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+# WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+#
+##
+#/*++
+#
+# Module Name:
+#
+# HIIConfigAccessBBTest.inf
+#
+# Abstract:
+#
+# Component description file for IHV HII Config Access Protocol Black-Box Test.
+#
+#--*/
+
+[defines]
+INF_VERSION = 0x00010005
+BASE_NAME = IhvHIIConfigAccessBBTest
+FILE_GUID = D39F2A3B-72BF-40F5-86BF-2E1E96D15EA3
+MODULE_TYPE = UEFI_DRIVER
+VERSION_STRING = 1.0
+ENTRY_POINT = InitializeHIIConfigAccessBBTest
+
+[sources.common]
+ HIIConfigAccessBBTestConformance.c
+ HIIConfigAccessBBTestFunction.c
+ HIIConfigAccessBBTestMain.c
+ Guid.c
+
+[Packages]
+ SctPkg/SctPkg.dec
+ SctPkg/UEFI/UEFI.dec
+ MdePkg/MdePkg.dec
+
+[LibraryClasses]
+ UefiDriverEntryPoint
+ SctLib
+ EfiTestLib
+
+[Protocols]
+ gBlackBoxEfiHIIConfigAccessProtocolGuid
+ gBlackBoxEfiHIIConfigRoutingProtocolGuid
+ gBlackBoxEfiDevicePathProtocolGuid
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h
new file mode 100644
index 000000000000..0baaf4b72539
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h
@@ -0,0 +1,82 @@
+/** @file
+
+ Copyright 2006 - 2011 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+ Module Name:
+
+ Guid.h
+
+ Abstract:
+
+ GUIDs auto-generated for EFI test assertion.
+
+--*/
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_001_GUID \
+{ 0xa7173eb5, 0xf76a, 0x4ea1, { 0x95, 0xd, 0x14, 0x91, 0x1e, 0x49, 0x86, 0xc1 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid001;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_002_GUID \
+{ 0xfa5973e2, 0xd05, 0x44c2, { 0xaf, 0x2d, 0x1b, 0x68, 0x33, 0x42, 0x6d, 0x76 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid002;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_003_GUID \
+{ 0x6f6d1dd, 0x49b8, 0x488a, { 0xa7, 0x75, 0xde, 0xbc, 0xc7, 0x60, 0xfd, 0x28 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid003;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_004_GUID \
+{ 0x28652613, 0x6bf4, 0x4f42, { 0xab, 0xe2, 0x84, 0x4f, 0x2f, 0x77, 0xec, 0x2f } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid004;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_005_GUID \
+{ 0xebba197a, 0x467f, 0x4736, { 0x92, 0xf2, 0x11, 0xb1, 0x91, 0x2e, 0xe9, 0x90 } }
+
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid005;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_006_GUID \
+{ 0x341fe3e0, 0xf688, 0x45f2, { 0x91, 0x56, 0xc7, 0xae, 0x9f, 0x2c, 0xcb, 0xb0 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid006;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_007_GUID \
+{ 0x1f99ebc8, 0x253, 0x455f, { 0x88, 0xac, 0x9e, 0x2b, 0xa6, 0xdc, 0xd7, 0x29 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid007;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_001_GUID \
+{ 0x24dcf8bf, 0xbfbf, 0x4588, { 0xba, 0xf, 0x77, 0x1e, 0x24, 0x4e, 0x3e, 0x8 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid001;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_002_GUID \
+{ 0x961a5268, 0x1998, 0x4a7e, { 0x9d, 0x9d, 0xce, 0xdc, 0x67, 0xfb, 0xcc, 0x77 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid002;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_003_GUID \
+{ 0x603e52f0, 0x2ce3, 0x4e7a, { 0xa7, 0x2e, 0xdf, 0x8c, 0xa3, 0xfd, 0xb2, 0xd } }
+
+extern EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid003;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_004_GUID \
+{ 0xab163674, 0x6c27, 0x4169, { 0xa6, 0xa9, 0xe1, 0x9c, 0x88, 0x14, 0x94, 0x96 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid004;
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.h b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.h
new file mode 100644
index 000000000000..acd0fabc7fc7
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.h
@@ -0,0 +1,145 @@
+/** @file
+
+ Copyright 2006 - 2013 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+Module Name:
+
+ HIIConfigAccessBBTestMain.h
+
+Abstract:
+
+ Test Driver of HII Configuration Access Protocol header file
+
+--*/
+
+#ifndef _HII_CONFIG_ACCESS_BB_TEST_MAIN
+#define _HII_CONFIG_ACCESS_BB_TEST_MAIN
+
+#define __UEFI_INTERNAL_FORMREPRESENTATION_H__
+#include <Base.h>
+#include "SctLib.h"
+#include "Guid.h"
+#include <Library/EfiTestLib.h>
+#include <UEFI/Protocol/Hii.h>
+#include <UEFI/Protocol/HIIConfigAccess.h>
+#include <UEFI/Protocol/HIIConfigRouting.h>
+
+
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_REVISION 0x00010000
+#define IHV_EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID \
+{ 0x68820884, 0x4be3, 0x4ca9, { 0x83, 0x81, 0x9e, 0x98, 0xf3, 0xf4, 0x8d, 0xaf } }
+//
+// Entry GUIDs for Func Test
+//
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0101 \
+{ 0x2a85387e, 0xdcf9, 0x45e9, { 0xb3, 0x8f, 0x5d, 0xa1, 0x75, 0x41, 0xcf, 0x1a } }
+
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0102 \
+{ 0x1a15df85, 0x6cc1, 0x43f2, { 0x9b, 0x86, 0x21, 0x8b, 0xd5, 0xfd, 0xf4, 0xa0 } }
+
+
+//
+// Entry GUIDs for Conf Test
+//
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0201 \
+{ 0xe2c3b0fe, 0xfbe9, 0x46a9, { 0xa3, 0x1b, 0xa3, 0xf3, 0x82, 0xd, 0xcf, 0x4 } }
+
+#define EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0202 \
+{ 0x495c99f3, 0x231, 0x45a5, { 0xaf, 0xfa, 0xd2, 0x5c, 0x6f, 0x9a, 0x19, 0x1c } }
+
+
+
+EFI_STATUS
+InitializeHIIConfigAccessBBTest (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ );
+
+
+EFI_STATUS
+UnloadHIIConfigAccessBBTest (
+ IN EFI_HANDLE ImageHandle
+ );
+
+
+//
+//Test Cases
+//
+
+EFI_STATUS
+BBTestExtractConfigConformanceTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ );
+
+EFI_STATUS
+BBTestRouteConfigConformanceTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ );
+
+EFI_STATUS
+BBTestExtractConfigFunctionTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ );
+
+EFI_STATUS
+BBTestRouteConfigFunctionTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ );
+
+EFI_STATUS
+GetDevicePath (
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess,
+ OUT EFI_STRING *DevicePathStr
+ );
+
+EFI_STATUS
+GetCorrespondingRequest (
+ IN EFI_STRING MultiConfigAltResp,
+ IN EFI_STRING DevicePath,
+ IN OUT EFI_STRING Request
+ );
+
+EFI_STATUS
+GetCorrespondingResp (
+ IN EFI_STRING MultiConfigAltResp,
+ IN EFI_STRING DevicePath,
+ IN OUT EFI_STRING Resp
+ );
+
+EFI_STATUS
+GetHIIConfigRoutingInterface (
+ OUT EFI_HII_CONFIG_ROUTING_PROTOCOL **HIIConfigRouting
+ );
+
+EFI_STATUS
+MultiAltRespToMultiReq (
+ IN EFI_STRING Resp,
+ IN OUT EFI_STRING Req
+ );
+
+#endif
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.c b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.c
new file mode 100644
index 000000000000..a5258eae0714
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.c
@@ -0,0 +1,50 @@
+/** @file
+
+ Copyright 2006 - 2012 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+ Module Name:
+
+ Guid.c
+
+ Abstract:
+
+ GUIDs auto-generated for EFI test assertion.
+
+--*/
+
+#include "HIIConfigAccessBBTestMain.h"
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid001=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_001_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid002=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_002_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid003=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_003_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid004=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_004_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid005=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_005_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid006=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_006_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid007=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_007_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid001=EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_001_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid002=EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_002_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid003=EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_003_GUID;
+
+EFI_GUID gHIIConfigAccessBBTestFunctionAssertionGuid004=EFI_TEST_HIICONFIGACCESSBBTESTFUNCTION_ASSERTION_004_GUID;
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c
new file mode 100644
index 000000000000..917f5d3c41f5
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c
@@ -0,0 +1,619 @@
+/** @file
+
+ Copyright 2006 - 2016 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+Module Name:
+ HIIConfigAccessBBTestConformance.c
+
+Abstract:
+ for EFI Driver HII Configuration Access Protocol's conformance Test
+
+--*/
+
+#include "HIIConfigAccessBBTestMain.h"
+
+EFI_BROWSER_ACTION EFI_BROWSER_ACTION_UNSUPPORTED = 2;
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint3 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint4 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint3 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestExtractConfigConformanceTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ )
+{
+ EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
+ EFI_STATUS Status;
+ EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess;
+ EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting;
+
+ //
+ // init
+ //
+ HIIConfigAccess = (EFI_HII_CONFIG_ACCESS_PROTOCOL*)ClientInterface;
+
+ //
+ // Get the Standard Library Interface
+ //
+ Status = gtBS->HandleProtocol (
+ SupportHandle,
+ &gEfiStandardTestLibraryGuid,
+ (VOID **) &StandardLib
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //
+ // Get the Config Routing Protocol Interface
+ //
+ Status = GetHIIConfigRoutingInterface( &HIIConfigRouting );
+ if ( EFI_ERROR(Status) ) {
+ return Status;
+ }
+
+ //
+ //Call check points
+ //
+ BBTestExtractConfigConformanceTestCheckpoint1( StandardLib, HIIConfigAccess );
+ BBTestExtractConfigConformanceTestCheckpoint2( StandardLib, HIIConfigRouting, HIIConfigAccess );
+ BBTestExtractConfigConformanceTestCheckpoint3( StandardLib, HIIConfigRouting, HIIConfigAccess );
+ BBTestExtractConfigConformanceTestCheckpoint4( StandardLib, HIIConfigAccess );
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+BBTestRouteConfigConformanceTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ )
+{
+ EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
+ EFI_STATUS Status;
+ EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess;
+ EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting;
+
+ //
+ // init
+ //
+ HIIConfigAccess = (EFI_HII_CONFIG_ACCESS_PROTOCOL*)ClientInterface;
+
+ //
+ // Get the Standard Library Interface
+ //
+ Status = gtBS->HandleProtocol (
+ SupportHandle,
+ &gEfiStandardTestLibraryGuid,
+ (VOID **) &StandardLib
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //
+ // Get the Config Routing Protocol Interface
+ //
+ Status = GetHIIConfigRoutingInterface( &HIIConfigRouting );
+ if ( EFI_ERROR(Status) ) {
+ return Status;
+ }
+
+ //
+ //Call check points
+ //
+ BBTestRouteConfigConformanceTestCheckpoint1( StandardLib, HIIConfigAccess );
+ BBTestRouteConfigConformanceTestCheckpoint2( StandardLib, HIIConfigRouting, HIIConfigAccess );
+ BBTestRouteConfigConformanceTestCheckpoint3( StandardLib, HIIConfigAccess );
+
+ return EFI_SUCCESS;
+}
+
+//
+//Check Points
+//
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Progress = NULL;
+ EFI_STRING Results = NULL;
+ EFI_STRING ResultsPtr = NULL;
+ UINTN Len = 0;
+ CHAR16* Pointer = NULL;
+ UINT8 IfMulti = 0;
+
+ EFI_STRING Request = NULL;
+ //
+ // Call ExtractConfig with Request been <MultiConfigRequest>
+ //
+ Status = HIIConfigAccess->ExtractConfig (
+ HIIConfigAccess,
+ NULL,
+ &Progress,
+ &Results
+ );
+
+ if ( Status == EFI_SUCCESS ) {
+ Len = SctStrLen (Results);
+ //
+ // Make sure the size of Request is enough to hold <MultiConfigRequest>
+ // if original Results is not Multi
+ //
+ Request = (EFI_STRING) SctAllocateZeroPool ( 2 * Len + 2 + 256);
+ if (Request == NULL) {
+ SctFreePool (Results);
+ return EFI_OUT_OF_RESOURCES;
+ }
+ } else {
+ return Status;
+ }
+
+ Status = MultiAltRespToMultiReq (Results, Request);
+ ResultsPtr = Request;
+
+ SctFreePool (Results);
+ Results = NULL;
+
+ if ( SctStrStr (Request, L"GUID=") != NULL ) {
+ Pointer = SctStrStr (Request, L"GUID=");
+ Pointer++;
+ if ( SctStrStr (Pointer, L"GUID=") != NULL )
+ IfMulti = 1;
+ }
+
+ if ( IfMulti == 0 ) {
+ SctStrCat ( Request, L"&GUID=970eb94aa0d449f7b980bdaa47d42527&NAME=006a0069006e0039&PATH=000acf&grag&star");
+ }
+
+ Status = HIIConfigAccess->ExtractConfig (
+ HIIConfigAccess,
+ Request,
+ &Progress,
+ &Results
+ );
+
+ if ( (EFI_INVALID_PARAMETER != Status) || (SctStrnCmp (Progress, L"&GUID=", 6) != 0) ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid001,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_INVALID_PARAMETER with Request been <MultiConfigRequest>.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+ SctFreePool (Request);
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Request = NULL;
+ EFI_STRING Results = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+ EFI_STRING DevicePath = NULL;
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ return Status;
+ }
+
+ Request = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (Request == NULL) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = GetCorrespondingRequest (MultiConfigAltResp, DevicePath, Request);
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+ return Status;
+ }
+
+ //
+ // Call ExtractConfig with Progress been NULL
+ //
+ Status = HIIConfigAccess->ExtractConfig (
+ HIIConfigAccess,
+ Request,
+ NULL,
+ &Results
+ );
+
+ if ( EFI_INVALID_PARAMETER != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid002,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_INVALID_PARAMETER with Progress been NULL.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint3 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Request = NULL;
+ EFI_STRING Progress = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+ EFI_STRING DevicePath = NULL;
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ return Status;
+ }
+
+ Request = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (Request == NULL) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = GetCorrespondingRequest (MultiConfigAltResp, DevicePath, Request);
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+ return Status;
+ }
+ //
+ // Call ExtractConfig with Results been NULL
+ //
+ Status = HIIConfigAccess->ExtractConfig (
+ HIIConfigAccess,
+ Request,
+ &Progress,
+ NULL
+ );
+
+ if ( EFI_INVALID_PARAMETER != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid003,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_INVALID_PARAMETER with Results been NULL.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+BBTestExtractConfigConformanceTestCheckpoint4 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Request;
+ EFI_STRING Progress = NULL;
+ EFI_STRING Results = NULL;
+
+ //init the Request
+ Request = L"GUID=71e430fb2e8849779d7a33ef1139e7ed&NAME=006a0069006e0039&PATH=000acf&Jack&Rons&Nash&Mary";
+
+ //
+ // Call ExtractConfig with unknown name
+ //
+ Status = HIIConfigAccess->ExtractConfig (
+ HIIConfigAccess,
+ Request,
+ &Progress,
+ &Results
+ );
+
+ if ( ((EFI_INVALID_PARAMETER == Status) && (SctStrnCmp (Progress, L"&Jack&Rons&Nash&Mary", 20) == 0)) ||
+ ((EFI_NOT_FOUND == Status) && (Progress == Request)) ) {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid004,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig - ExtractConfig() returns EFI_INVALID_PARAMETER/EFI_NOT_FOUND with invalid input.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Progress = NULL;
+
+
+ //
+ // Call RouteConfig with Configuration been NULL
+ //
+ Status = HIIConfigAccess->RouteConfig (
+ HIIConfigAccess,
+ NULL,
+ &Progress
+ );
+
+ if ( EFI_INVALID_PARAMETER != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid005,
+ L"HII_CONFIG_ACCESS_PROTOCOL.RouteConfig - RouteConfig() returns EFI_INVALID_PARAMETER with Configuration been NULL.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+ return EFI_SUCCESS;
+ }
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Config = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+ EFI_STRING DevicePath = NULL;
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ return Status;
+ }
+
+ Config = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (Config == NULL) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = GetCorrespondingResp (MultiConfigAltResp, DevicePath, Config);
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Config);
+ return Status;
+ }
+
+ //
+ // Call RouteConfig with Progress been NULL
+ //
+ Status = HIIConfigAccess->RouteConfig (
+ HIIConfigAccess,
+ Config,
+ NULL
+ );
+
+ if ( EFI_INVALID_PARAMETER != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid006,
+ L"HII_CONFIG_ACCESS_PROTOCOL.RouteConfig - RouteConfig() returns EFI_INVALID_PARAMETER with Progress been NULL.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Config);
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+BBTestRouteConfigConformanceTestCheckpoint3 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Configuration;
+ EFI_STRING Progress = NULL;
+
+ //init the Configuration
+ Configuration=L"GUID=71e430fb2e8849779d7a33ef1139e7ed&NAME=006a0069006e0039&PATH=0acf&OFFSET=2&WIDTH=3VALUE=45AF";
+
+ //
+ // Call RouteConfig with no found target for the routing data
+ //
+ Status = HIIConfigAccess->RouteConfig (
+ HIIConfigAccess,
+ Configuration,
+ &Progress
+ );
+
+ if ( EFI_NOT_FOUND != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestConformanceAssertionGuid007,
+ L"HII_CONFIG_ACCESS_PROTOCOL.RouteConfig - RouteConfig() returns EFI_NOT_FOUND with no found target for the routing data.",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ return EFI_SUCCESS;
+}
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestFunction.c b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestFunction.c
new file mode 100644
index 000000000000..a17749a1a458
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestFunction.c
@@ -0,0 +1,451 @@
+/** @file
+
+ Copyright 2006 - 2017 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+Module Name:
+ HIIConfigAccessBBTestFunction.c
+
+Abstract:
+ for EFI Driver HII Configuration Access Protocol's function Test
+
+--*/
+
+#include "HIIConfigAccessBBTestMain.h"
+
+
+EFI_STATUS
+BBTestExtractConfigFunctionTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestExtractConfigFunctionTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+EFI_STATUS
+BBTestRouteConfigFunctionTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ );
+
+//
+//Test Cases
+//
+
+EFI_STATUS
+BBTestExtractConfigFunctionTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ )
+{
+ EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
+ EFI_STATUS Status;
+ EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess;
+ EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting;
+
+ //
+ // init
+ //
+ HIIConfigAccess = (EFI_HII_CONFIG_ACCESS_PROTOCOL*)ClientInterface;
+
+ //
+ // Get the Standard Library Interface
+ //
+ Status = gtBS->HandleProtocol (
+ SupportHandle,
+ &gEfiStandardTestLibraryGuid,
+ (VOID **) &StandardLib
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //
+ // Get the Config Routing Protocol Interface
+ //
+ Status = GetHIIConfigRoutingInterface( &HIIConfigRouting );
+ if ( EFI_ERROR(Status) ) {
+ return Status;
+ }
+
+ //
+ //Call check points
+ //
+ BBTestExtractConfigFunctionTestCheckpoint1( StandardLib, HIIConfigRouting, HIIConfigAccess );
+ BBTestExtractConfigFunctionTestCheckpoint2( StandardLib, HIIConfigRouting, HIIConfigAccess );
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+BBTestRouteConfigFunctionTest (
+ IN EFI_BB_TEST_PROTOCOL *This,
+ IN VOID *ClientInterface,
+ IN EFI_TEST_LEVEL TestLevel,
+ IN EFI_HANDLE SupportHandle
+ )
+{
+ EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib;
+ EFI_STATUS Status;
+ EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess;
+ EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting;
+
+ //
+ // init
+ //
+ HIIConfigAccess = (EFI_HII_CONFIG_ACCESS_PROTOCOL*)ClientInterface;
+
+ //
+ // Get the Standard Library Interface
+ //
+ Status = gtBS->HandleProtocol (
+ SupportHandle,
+ &gEfiStandardTestLibraryGuid,
+ (VOID **) &StandardLib
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //
+ // Get the Config Routing Protocol Interface
+ //
+ Status = GetHIIConfigRoutingInterface( &HIIConfigRouting );
+ if ( EFI_ERROR(Status) ) {
+ return Status;
+ }
+
+ //
+ //Call check points
+ //
+ BBTestRouteConfigFunctionTestCheckpoint1( StandardLib, HIIConfigRouting, HIIConfigAccess );
+
+ return EFI_SUCCESS;
+}
+
+//
+//Check Points
+//
+EFI_STATUS
+BBTestExtractConfigFunctionTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Request = NULL;
+ EFI_STRING ConfigHdr = NULL;
+ EFI_STRING Progress = NULL;
+ EFI_STRING Results = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+ EFI_STRING DevicePath = NULL;
+
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ return Status;
+ }
+
+ Request = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (Request == NULL) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = GetCorrespondingRequest (MultiConfigAltResp, DevicePath, Request);
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+ return Status;
+ }
+
+ //
+ // Call ExtractConfig with valid parameters
+ //
+ Status = HIIConfigAccess->ExtractConfig(
+ HIIConfigAccess,
+ Request,
+ &Progress,
+ &Results
+ );
+
+ if ( (EFI_SUCCESS == Status) && (Progress == (Request + SctStrLen (Request))) ) {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ if (Results == NULL) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ gtBS->FreePool (Results);
+ }
+ } else if (EFI_OUT_OF_RESOURCES == Status) {
+ AssertionType = EFI_TEST_ASSERTION_WARNING;
+ }else {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestFunctionAssertionGuid001,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig- ExtractConfig() returns EFI_SUCCESS and vaild Results with valid parameters .",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ //
+ // Change the Request to ConfigHdr
+ //
+ ConfigHdr = Request;
+ while (*Request) {
+ if (*Request == L'&') {
+ if (SctStrnCmp (Request, L"&NAME=", 6) == 0) {
+ Request = Request + 6;
+ } else if (SctStrnCmp (Request, L"&PATH=", 6) == 0) {
+ Request = Request + 6;
+ } else {
+ *Request = 0;
+ }
+ } else {
+ Request++;
+ }
+ }
+ Request = ConfigHdr;
+
+ //
+ // Call ExtractConfig when Request is ConfigHdr
+ //
+ Progress = NULL;
+ Results = NULL;
+ Status = HIIConfigAccess->ExtractConfig(
+ HIIConfigAccess,
+ Request,
+ &Progress,
+ &Results
+ );
+
+ if ( (EFI_SUCCESS == Status) && (Progress == (Request + SctStrLen (Request))) ) {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ if (Results == NULL) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ } else {
+ if (NULL == SctStrStr (Results, Request)) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ gtBS->FreePool (Results);
+ }
+ } else if (EFI_OUT_OF_RESOURCES == Status) {
+ AssertionType = EFI_TEST_ASSERTION_WARNING;
+ }else {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestFunctionAssertionGuid002,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig- ExtractConfig() returns EFI_SUCCESS and vaild Results with valid parameters .",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Request);
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+BBTestExtractConfigFunctionTestCheckpoint2 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Request = NULL;
+ EFI_STRING Progress = NULL;
+ EFI_STRING Results = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ //
+ // Call ExtractConfig with valid parameters
+ //
+ Status = HIIConfigAccess->ExtractConfig(
+ HIIConfigAccess,
+ NULL,
+ &Progress,
+ &Results
+ );
+
+ if (EFI_OUT_OF_RESOURCES == Status) {
+ AssertionType = EFI_TEST_ASSERTION_WARNING;
+ } else if ((EFI_NOT_FOUND == Status) && (Progress == NULL) && (Results == NULL)) {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ } else if ( EFI_SUCCESS != Status ) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ if (Results != NULL) {
+ gtBS->FreePool (Results);
+ }
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ if (Results == NULL) {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestFunctionAssertionGuid003,
+ L"HII_CONFIG_ACCESS_PROTOCOL.ExtractConfig- ExtractConfig() returns EFI_SUCCESS or EFI_NOT_FOUND with Request been NULL .",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+
+ if ( NULL != MultiConfigAltResp ){
+ gtBS->FreePool (MultiConfigAltResp);
+ }
+
+ if ( NULL !=Results ) {
+ gtBS->FreePool (Results);
+ }
+
+ if (NULL != Request) {
+ gtBS->FreePool (Request);
+ }
+
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+BBTestRouteConfigFunctionTestCheckpoint1 (
+ IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *StandardLib,
+ IN EFI_HII_CONFIG_ROUTING_PROTOCOL *HIIConfigRouting,
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *HIIConfigAccess
+ )
+{
+ EFI_STATUS Status;
+ EFI_TEST_ASSERTION AssertionType;
+
+ EFI_STRING Resp = NULL;
+ EFI_STRING Progress = NULL;
+ EFI_STRING MultiConfigAltResp = NULL;
+ EFI_STRING DevicePath = NULL;
+
+ //init the Request
+ Status = HIIConfigRouting->ExportConfig(
+ HIIConfigRouting,
+ &MultiConfigAltResp
+ );
+ if (EFI_ERROR(Status)) {
+ return Status;
+ }
+
+ Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ return Status;
+ }
+
+ Resp = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (Resp == NULL) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ return EFI_OUT_OF_RESOURCES;
+ }
+
+ Status = GetCorrespondingResp (MultiConfigAltResp, DevicePath, Resp);
+ if (EFI_ERROR(Status)) {
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Resp);
+ return Status;
+ }
+
+ //
+ // Call RouteConfig with valid parameters
+ //
+ Status = HIIConfigAccess->RouteConfig(
+ HIIConfigAccess,
+ Resp,
+ &Progress
+ );
+ if ( (EFI_SUCCESS == Status) && (Progress == Resp + SctStrLen (Resp)) ) {
+ AssertionType = EFI_TEST_ASSERTION_PASSED;
+ } else if ( EFI_OUT_OF_RESOURCES == Status ) {
+ AssertionType = EFI_TEST_ASSERTION_WARNING;
+ } else {
+ AssertionType = EFI_TEST_ASSERTION_FAILED;
+ }
+ StandardLib->RecordAssertion (
+ StandardLib,
+ AssertionType,
+ gHIIConfigAccessBBTestFunctionAssertionGuid003,
+ L"HII_CONFIG_ACCESS_PROTOCOL.RouteConfig- RouteConfig() returns EFI_SUCCESS with valid parameters .",
+ L"%a:%d: Status - %r",
+ __FILE__,
+ (UINTN)__LINE__,
+ Status
+ );
+
+ gtBS->FreePool (MultiConfigAltResp);
+ gtBS->FreePool (DevicePath);
+ gtBS->FreePool (Resp);
+
+ return EFI_SUCCESS;
+}
diff --git a/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.c b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.c
new file mode 100644
index 000000000000..92de424a496f
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.c
@@ -0,0 +1,621 @@
+/** @file
+
+ Copyright 2006 - 2016 Unified EFI, Inc.<BR>
+ Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<BR>
+ Copyright (c) 2019,Microchip Technology Inc.<BR>
+
+ This program and the accompanying materials
+ are licensed and made available under the terms and conditions of the BSD License
+ which accompanies this distribution. The full text of the license may be found at
+ http://opensource.org/licenses/bsd-license.php
+
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
+
+**/
+/*++
+
+Module Name:
+
+ HIIConfigAccessBBTestMain.c
+
+Abstract:
+
+ Test Driver of HII Configuration Access Protocol
+
+--*/
+
+#include "HIIConfigAccessBBTestMain.h"
+
+//
+// Global variables
+//
+EFI_HANDLE mImageHandle;
+
+EFI_BB_TEST_PROTOCOL *gBBTestProtocolInterface;
+
+EFI_BB_TEST_PROTOCOL_FIELD gBBTestProtocolField = {
+ EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_REVISION,
+ IHV_EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID,
+ L"HII Configuration Access Protocol Test",
+ L"UEFI HII Configuration Access Protocol Black-Box Test"
+};
+
+EFI_GUID gSupportProtocolGuid[] = {
+ EFI_STANDARD_TEST_LIBRARY_GUID,
+ EFI_NULL_GUID
+};
+
+EFI_BB_TEST_ENTRY_FIELD gBBTestEntryField[] = {
+ {
+ EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0101,
+ L"ExtractConfigFunction",
+ L"Function auto test for HII Configuration Access Protocol ExtractConfig().",
+ EFI_TEST_LEVEL_MINIMAL,
+ gSupportProtocolGuid,
+ EFI_TEST_CASE_AUTO,
+ BBTestExtractConfigFunctionTest
+ },
+ {
+ EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0102,
+ L"RouteConfigFunction",
+ L"Function auto test for HII Configuration Access Protocol RouteConfig().",
+ EFI_TEST_LEVEL_MINIMAL,
+ gSupportProtocolGuid,
+ EFI_TEST_CASE_AUTO,
+ BBTestRouteConfigFunctionTest
+ },
+ {
+ EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0201,
+ L"ExtractConfigConformance",
+ L"Conformance auto test for HII Configuration Access Protocol ExtractConfig().",
+ EFI_TEST_LEVEL_MINIMAL,
+ gSupportProtocolGuid,
+ EFI_TEST_CASE_AUTO,
+ BBTestExtractConfigConformanceTest
+ },
+ {
+ EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0202,
+ L"RouteConfigConformance",
+ L"Conformance auto test for HII Configuration Access Protocol RouteConfig().",
+ EFI_TEST_LEVEL_MINIMAL,
+ gSupportProtocolGuid,
+ EFI_TEST_CASE_AUTO,
+ BBTestRouteConfigConformanceTest
+ },
+ 0
+};
+
+
+
+
+EFI_STATUS
+InitializeHIIConfigAccessBBTest (
+ IN EFI_HANDLE ImageHandle,
+ IN EFI_SYSTEM_TABLE *SystemTable
+ )
+{
+ EfiInitializeTestLib (ImageHandle, SystemTable);
+
+ //
+ // initialize test utility lib
+ //
+
+ SctInitializeLib (ImageHandle, SystemTable);
+
+ mImageHandle = ImageHandle;
+
+ return EfiInitAndInstallIHVBBTestInterface (
+ &ImageHandle,
+ &gBBTestProtocolField,
+ gBBTestEntryField,
+ UnloadHIIConfigAccessBBTest,
+ &gBBTestProtocolInterface
+ );
+}
+
+
+EFI_STATUS
+UnloadHIIConfigAccessBBTest (
+ IN EFI_HANDLE ImageHandle
+ )
+{
+ return EfiUninstallAndFreeIHVBBTestInterface (
+ ImageHandle,
+ gBBTestProtocolInterface
+ );
+}
+
+
+// Assistance Function
+UINTN
+EfiDevicePathSize (
+ IN EFI_DEVICE_PATH_PROTOCOL *DevicePath
+ )
+/*++
+
+Routine Description:
+
+ Calculate the space size of a device path.
+
+Arguments:
+
+ DevicePath - A specified device path
+
+Returns:
+
+ The size.
+
+--*/
+{
+ EFI_DEVICE_PATH_PROTOCOL *Start;
+
+ if (DevicePath == NULL) {
+ return 0;
+ }
+
+ //
+ // Search for the end of the device path structure
+ //
+ Start = DevicePath;
+ while (!SctIsDevicePathEnd (DevicePath)) {
+ DevicePath = SctNextDevicePathNode (DevicePath);
+ }
+
+ //
+ // Compute the size and add back in the size of the end device path structure
+ //
+ return ((UINTN) DevicePath - (UINTN) Start) + sizeof (EFI_DEVICE_PATH_PROTOCOL);
+}
+
+
+STATIC
+CHAR16
+NibbleToHexCharPrivate (
+ IN UINT8 Nibble
+ )
+/*++
+
+ Routine Description:
+ Converts the low nibble of a byte to hex unicode character.
+
+ Arguments:
+ Nibble - lower nibble of a byte.
+
+ Returns:
+ Hex unicode character between L'0' to L'f'.
+
+--*/
+{
+ Nibble &= 0x0F;
+
+ if (Nibble <= 0x9) {
+ return (CHAR16)(Nibble + L'0');
+ }
+
+ return (CHAR16)(Nibble - 0xA + L'a');
+}
+
+
+STATIC
+EFI_STATUS
+BufToHexStringPrivate (
+ IN OUT CHAR16 *Str,
+ IN OUT UINTN *HexStringBufferLength,
+ IN UINT8 *Buf,
+ IN UINTN Len,
+ IN BOOLEAN Flag
+ )
+/*++
+
+ Routine Description:
+ Converts binary buffer to Unicode string.
+ At a minimum, any blob of data could be represented as a hex string.
+
+ Arguments:
+ Str - Pointer to the string.
+ HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
+ If routine return with EFI_SUCCESS, containing length of hex string buffer.
+ If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
+ Buf - Buffer to be converted from.
+ Len - Length in bytes of the buffer to be converted.
+ Flag - If TRUE, encode the data in the same order as the it
+ resides in the Buf. Else encode it in the reverse direction.
+
+ Returns:
+ EFI_SUCCESS - Routine success.
+ EFI_BUFFER_TOO_SMALL - The hex string buffer is too small.
+
+--*/
+{
+ UINTN Idx;
+ UINT8 Byte;
+ UINTN StrLen;
+
+ //
+ // Make sure string is either passed or allocate enough.
+ // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer.
+ // Plus the Unicode termination character.
+ //
+ StrLen = Len * 2;
+ if ((*HexStringBufferLength) < (StrLen + 1) * sizeof (CHAR16)) {
+ *HexStringBufferLength = (StrLen + 1) * sizeof (CHAR16);
+ return EFI_BUFFER_TOO_SMALL;
+ }
+
+ *HexStringBufferLength = (StrLen + 1) * sizeof (CHAR16);
+
+ //
+ // Ends the string.
+ //
+ Str[StrLen] = 0;
+
+ for (Idx = 0; Idx < Len; Idx++) {
+
+ Byte = Buf[Idx];
+ if (Flag) {
+ Str[Idx * 2] = NibbleToHexCharPrivate ((UINT8)(Byte >> 4));
+ Str[Idx * 2 + 1] = NibbleToHexCharPrivate (Byte);
+ } else {
+ Str[StrLen - 1 - Idx * 2] = NibbleToHexCharPrivate (Byte);
+ Str[StrLen - 2 - Idx * 2] = NibbleToHexCharPrivate ((UINT8)(Byte >> 4));
+ }
+ }
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+GetDevicePath (
+ IN EFI_HII_CONFIG_ACCESS_PROTOCOL *ConfigAccess,
+ OUT EFI_STRING *DevicePathStr
+ )
+{
+ EFI_STATUS Status;
+ UINTN Index;
+ UINTN NoHandles;
+ EFI_HANDLE *HandleBuffer;
+ EFI_HANDLE ConfigAccessHandle = NULL;
+ EFI_HII_CONFIG_ACCESS_PROTOCOL *TestedConfigAccess;
+ EFI_DEVICE_PATH_PROTOCOL *DevicePath;
+ UINTN Length;
+ UINTN PathHdrSize;
+
+ //
+ // locate all Hii Configuration Access Protocol Instances
+ //
+ Status = gtBS->LocateHandleBuffer (
+ ByProtocol,
+ &gBlackBoxEfiHIIConfigAccessProtocolGuid,
+ NULL,
+ &NoHandles,
+ &HandleBuffer
+ );
+ if (EFI_ERROR(Status) || (NoHandles == 0)) {
+ return EFI_NOT_FOUND;
+ }
+
+ //
+ // scan for the handle that matched with the Hii Configuration Access Protocol that
+ // passed in by the test framework
+ //
+ for (Index = 0; Index < NoHandles; Index++) {
+ Status = gtBS->HandleProtocol (
+ HandleBuffer[Index],
+ &gBlackBoxEfiHIIConfigAccessProtocolGuid,
+ (VOID **) &TestedConfigAccess
+ );
+ if (EFI_ERROR(Status)) {
+ continue;
+ }
+
+ if (TestedConfigAccess == ConfigAccess) {
+ ConfigAccessHandle = HandleBuffer[Index];
+ break;
+ }
+ }
+
+ gtBS->FreePool (HandleBuffer);
+
+ if (ConfigAccessHandle == NULL) {
+ return EFI_NOT_FOUND;
+ }
+
+ //
+ // find controller handles managed by the component name handle.
+ //
+ Status = gtBS->HandleProtocol (
+ ConfigAccessHandle,
+ &gBlackBoxEfiDevicePathProtocolGuid,
+ (void **)&DevicePath
+ );
+
+ //
+ // Convert the device path binary to hex UNICODE %02x bytes in the same order
+ // as the device path resides in RAM memory.
+ //
+ Length = EfiDevicePathSize (DevicePath);
+ PathHdrSize = (Length * 2 + 1) * sizeof (CHAR16);
+ *DevicePathStr = (EFI_STRING) SctAllocateZeroPool (PathHdrSize);
+ if (*DevicePathStr == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ Status = BufToHexStringPrivate (*DevicePathStr, &PathHdrSize, (UINT8 *) DevicePath, Length, TRUE);
+
+ return Status;
+}
+
+
+EFI_STATUS
+GetCorrespondingRequest (
+ IN EFI_STRING MultiConfigAltResp,
+ IN EFI_STRING DevicePath,
+ IN OUT EFI_STRING Request
+ )
+{
+ EFI_STRING RespPtr;
+ EFI_STRING ReqPtr;
+ EFI_STRING SingleResp;
+ EFI_STRING SingleRespPtr;
+ UINTN Len;
+
+ ReqPtr = Request;
+ RespPtr = MultiConfigAltResp;
+
+ Len = SctStrLen (MultiConfigAltResp);
+
+ if (SctStrnCmp (MultiConfigAltResp, L"GUID=", 5) != 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (SctStrStr (MultiConfigAltResp, DevicePath) == NULL) {
+ return EFI_NOT_FOUND;
+ }
+
+ SingleResp = (EFI_STRING) SctAllocateZeroPool ( 2 * SctStrLen (MultiConfigAltResp) + 2 );
+ if (SingleResp == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ SingleRespPtr = SingleResp;
+
+ while (*MultiConfigAltResp != 0) {
+ while ((*MultiConfigAltResp != 0) && (SctStrnCmp (MultiConfigAltResp, L"&GUID=", 6) != 0)) {
+ *(SingleResp++) = *(MultiConfigAltResp++);
+ }
+ SingleResp = SingleRespPtr;
+ if (SctStrStr (SingleResp, DevicePath) != NULL)
+ break;
+ SctZeroMem (SingleRespPtr, 2 * Len + 2);
+ if (*MultiConfigAltResp != 0)
+ MultiConfigAltResp++;
+ }
+
+ if (SctStrStr (SingleResp, DevicePath) == NULL)
+ return EFI_NOT_FOUND;
+
+ if (SctStrStr (SingleResp, L"VALUE=") == NULL){
+ while (*SingleResp != 0) {
+ while ((*SingleResp != 0) && (SctStrnCmp (SingleResp, L"&PATH=", 6) != 0)) {
+ *(Request++) = *(SingleResp++);
+ }
+ *(Request++) = *(SingleResp++);
+ while ((*SingleResp != 0) && (*SingleResp != L'&')) {
+ *(Request++) = *(SingleResp++);
+ }
+ while (*SingleResp != 0){
+ if (*SingleResp != L'=') {
+ *(Request++) = *(SingleResp++);
+ } else {
+ while ((*SingleResp != 0) && (*SingleResp != L'&')) {
+ SingleResp++;
+ }
+ }
+ }
+ }
+ } else {
+ while (*SingleResp != 0) {
+ while ((*SingleResp != 0) && (SctStrnCmp (SingleResp, L"&VALUE=", 7)) != 0) {
+ *(Request++) = *(SingleResp++);
+ }
+ SingleResp++;
+ while ((*SingleResp != 0) && (*SingleResp != L'&'))
+ SingleResp++;
+ }
+
+ }
+
+ *Request = 0;
+
+ gtBS->FreePool (SingleRespPtr);
+ return EFI_SUCCESS;
+}
+
+
+EFI_STATUS
+GetCorrespondingResp (
+ IN EFI_STRING MultiConfigAltResp,
+ IN EFI_STRING DevicePath,
+ IN OUT EFI_STRING Resp
+ )
+{
+ EFI_STRING RespPtr;
+ EFI_STRING ReqPtr;
+ UINTN Len;
+
+ ReqPtr = Resp;
+ RespPtr = MultiConfigAltResp;
+
+ Len = SctStrLen (MultiConfigAltResp);
+
+ if (SctStrnCmp (MultiConfigAltResp, L"GUID=", 5) != 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ if (SctStrStr (MultiConfigAltResp, DevicePath) == NULL) {
+ return EFI_NOT_FOUND;
+ }
+
+ while (*MultiConfigAltResp != 0) {
+ while ((*MultiConfigAltResp != 0) && (SctStrnCmp (MultiConfigAltResp, L"&GUID=", 6) != 0)) {
+ *(Resp++) = *(MultiConfigAltResp++);
+ }
+ Resp = ReqPtr;
+ if (SctStrStr (Resp, DevicePath) != NULL)
+ break;
+ SctZeroMem (ReqPtr, 2 * Len + 2);
+ if (*MultiConfigAltResp != 0)
+ MultiConfigAltResp++;
+ }
+
+ if (SctStrStr (Resp, DevicePath) == NULL)
+ return EFI_NOT_FOUND;
+
+ return EFI_SUCCESS;
+}
+
+
+
+EFI_STATUS
+GetHIIConfigRoutingInterface (
+ OUT EFI_HII_CONFIG_ROUTING_PROTOCOL **HIIConfigRouting
+ )
+{
+ UINTN NoHandles;
+ EFI_HANDLE *HandleBuffer;
+ EFI_STATUS Status;
+
+ //
+ // Get the HII Database Protocol interface
+ //
+ Status = gtBS->LocateHandleBuffer (
+ ByProtocol,
+ &gBlackBoxEfiHIIConfigRoutingProtocolGuid,
+ NULL,
+ &NoHandles,
+ &HandleBuffer
+ );
+ if ( EFI_ERROR(Status) ) {
+ return Status;
+ }
+
+ if ( NoHandles <= 0 ) {
+ return EFI_DEVICE_ERROR;
+ }
+
+ Status = gtBS->HandleProtocol (
+ HandleBuffer[0],
+ &gBlackBoxEfiHIIConfigRoutingProtocolGuid,
+ (VOID **) HIIConfigRouting
+ );
+ if ( EFI_ERROR(Status) ) {
+ gtBS->FreePool ( HandleBuffer );
+ return Status;
+ }
+
+ gtBS->FreePool ( HandleBuffer );
+
+ return EFI_SUCCESS;
+}
+
+EFI_STATUS
+MultiAltRespToMultiReq (
+ IN EFI_STRING Resp,
+ IN OUT EFI_STRING Req
+ )
+{
+ EFI_STRING Pointer1 = Resp;
+ EFI_STRING Pointer2 = NULL;
+ EFI_STRING Pointer3 = Req;
+ EFI_STRING CfgHdr = NULL;
+ EFI_STRING FreePtr = NULL;
+ CHAR8 Flag = 0;
+
+ if (SctStrnCmp (Pointer1, L"GUID=", 5) != 0) {
+ return EFI_INVALID_PARAMETER;
+ }
+
+ Pointer2 = (EFI_STRING) SctAllocateZeroPool (2 * SctStrLen (Resp) + 2);
+ if (Pointer2 == NULL) {
+ return EFI_OUT_OF_RESOURCES;
+ }
+ FreePtr = Pointer2;
+
+ while (*Pointer1) {
+ if (SctStrnCmp (Pointer1, L"GUID=", 5) == 0) {
+ CfgHdr = Pointer2;
+ *(Pointer2++) = *(Pointer1++);
+ while (*Pointer1 != L'&') {
+ *(Pointer2++) = *(Pointer1++);
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&GUID=", 6) == 0) {
+ *(Pointer2++) = *(Pointer1++);
+ CfgHdr = Pointer2;
+ while (*Pointer1 != L'&') {
+ *(Pointer2++) = *(Pointer1++);
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&NAME=", 6) == 0) {
+ *(Pointer2++) = *(Pointer1++);
+ while (*Pointer1 != L'&') {
+ *(Pointer2++) = *(Pointer1++);
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&PATH=", 6) == 0) {
+ *(Pointer2++) = *(Pointer1++);
+ while (*Pointer1 != L'&') {
+ *(Pointer2++) = *(Pointer1++);
+ }
+ if (NULL == SctStrStr (Req, CfgHdr)){
+ if (*Req == L'G')
+ *(Pointer3++) = L'&';
+ SctStrCat (Req, CfgHdr);
+ Pointer3 += SctStrLen (CfgHdr);
+ Flag = 1;
+ } else {
+ Flag = 0;
+ }
+ }
+ while ((Flag == 1) && (SctStrnCmp (Pointer1, L"&GUID=", 6) != 0) && *Pointer1) {
+ if (SctStrnCmp (Pointer1, L"&OFFSET=", 8) == 0) {
+ *(Pointer3++) = *(Pointer1++);
+ while (*Pointer1 != L'&') {
+ *(Pointer3++) = *(Pointer1++);
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&WIDTH=", 7) == 0) {
+ *(Pointer3++) = *(Pointer1++);
+ while (*Pointer1 != L'&') {
+ *(Pointer3++) = *(Pointer1++);
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&VALUE=", 7) == 0) {
+ Pointer1 += 7;
+ while (*Pointer1 != L'&' && *Pointer1) {
+ Pointer1++;
+ }
+ }
+ if (SctStrnCmp (Pointer1, L"&ALTCFG=", 8) == 0) {
+ Pointer1 += 8;
+ while (*Pointer1 != L'&' && *Pointer1) {
+ Pointer1++;
+ }
+ }
+ if ((*Pointer1 == L'&') && (SctStrnCmp (Pointer1, L"&GUID=", 6) != 0) &&
+ (SctStrnCmp (Pointer1, L"&OFFSET=", 8) != 0) && (SctStrnCmp (Pointer1, L"&WIDTH=", 7) != 0)) {
+ *(Pointer3++) = *(Pointer1++);
+ while (*Pointer1 != L'=') {
+ *(Pointer3++) = *(Pointer1++);
+ }
+ while (*Pointer1 != L'&' && *Pointer1) {
+ Pointer1++;
+ }
+ }
+ }
+ Pointer1++;
+ }
+
+ SctFreePool (FreePtr);
+
+ return EFI_SUCCESS;
+}
--
2.20.0.windows.1
reply other threads:[~2019-09-12 3:02 UTC|newest]
Thread overview: [no followups] expand[flat|nested] mbox.gz Atom feed
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20190912030252.14420-1-eric.jin@intel.com \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox