public inbox for devel@edk2.groups.io
 help / color / mirror / Atom feed
From: "Eric Jin" <eric.jin@intel.com>
To: "devel@edk2.groups.io" <devel@edk2.groups.io>,
	"Jin, Eric" <eric.jin@intel.com>,
	shrishail <shrishail.patil@microchip.com>
Cc: "supreeth.venkatesh@arm.com" <supreeth.venkatesh@arm.com>,
	"Jeff.Booher-Kaeding@arm.com" <Jeff.Booher-Kaeding@arm.com>
Subject: Re: [edk2-test][PATCH] Adding HII to IHVSCT
Date: Wed, 17 Jul 2019 03:37:01 +0000	[thread overview]
Message-ID: <DA72DC7456565B47808A57108259571F637DD297@SHSMSX103.ccr.corp.intel.com> (raw)
In-Reply-To: <15B21220C2BCC530.20638@groups.io>

Hi Shrishail,

Thank you for the patch for adding HiiConfigAccess to IHV SCT.
Two comments below are about the patch format. They can be caught by edk2\BaseTools\Scripts\PatchCheck.py 
1) The commit message format is not valid:
 * Missing Signed-off-by! (Note: this must be added by the code contributor!)
https://github.com/tianocore/tianocore.github.io/wiki/Commit-Message-Format
2) Code format is not valid:  (I think the original code in EFI part also has this issue, but please help to correct them in the IHV part at first)
* Trailing whitespace found
* Tab character used

Another suggestion is to separate the patch to 2 or 3 in one series, eg, source, script, and or description file, When you send the v2.
Since the code comes from EFI part, and code exists serval years there, I think the test logic is correct with your patch. Don't forget to add your company info in the file header. Thanks.

Best Regards
Eric
-----Original Message-----
From: devel@edk2.groups.io <devel@edk2.groups.io> On Behalf Of Eric Jin
Sent: Wednesday, July 17, 2019 10:52 AM
To: shrishail <shrishail.patil@microchip.com>; devel@edk2.groups.io
Cc: Jin, Eric <eric.jin@intel.com>; supreeth.venkatesh@arm.com; Jeff.Booher-Kaeding@arm.com
Subject: [edk2-devel] FW:[edk2-test][PATCH] Adding HII to IHVSCT

Forward to devel@edk2.groups.io with public review.

-----Original Message-----
From: shrishail <shrishail.patil@microchip.com> 
Sent: Friday, July 12, 2019 5:47 PM
To: Jin, Eric <eric.jin@intel.com>
Cc: shrishailp <50140165+shrishailp@users.noreply.github.com>
Subject: [PATCH] Adding HII to IHVSCT

From: shrishailp <50140165+shrishailp@users.noreply.github.com>

Adding HII to IHVSCT
---
 uefi-sct/SctPkg/CommonGenFramework.bat        |   2 +-
 uefi-sct/SctPkg/CommonGenFramework.sh         |   2 +-
 uefi-sct/SctPkg/Config/Data/Category.ini      |   7 +
 .../HIIConfigAccess/BlackBoxTest/Guid.c       |  46 +
 .../HIIConfigAccess/BlackBoxTest/Guid.h       | 109 +++
 .../HIIConfigAccessBBTestConformance.c        | 908 ++++++++++++++++++
 .../HIIConfigAccessBBTestFunction.c           | 606 ++++++++++++
 .../BlackBoxTest/HIIConfigAccessBBTestMain.c  | 655 +++++++++++++
 .../BlackBoxTest/HIIConfigAccessBBTestMain.h  | 168 ++++
 .../BlackBoxTest/IhvHIIConfigAccessBBTest.inf |  55 ++
 uefi-sct/SctPkg/UEFI/IHV_SCT.dsc              |   1 +
 11 files changed, 2557 insertions(+), 2 deletions(-)
 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/Guid.h
 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
 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/IhvHIIConfigAccessBBTest.inf

diff --git a/uefi-sct/SctPkg/CommonGenFramework.bat b/uefi-sct/SctPkg/CommonGenFramework.bat
index 5c614eaa..8e75d8a8 100644
--- a/uefi-sct/SctPkg/CommonGenFramework.bat
+++ b/uefi-sct/SctPkg/CommonGenFramework.bat
@@ -279,7 +279,7 @@ rem  copy %ProcessorType%\IhvUsbHcTest.efi                         %Framework%\T
   copy %ProcessorType%\IhvUsb2HcTest.efi                        %Framework%\Test\ > NUL

   copy %ProcessorType%\IhviScsiInitiatorNameBBTest.efi          %Framework%\Test\ > NUL

   copy %ProcessorType%\IhvStorageSecurityCommandBBTest.efi      %Framework%\Test\ > NUL

-

+  copy %ProcessorType%\IhvHIIConfigAccessBBTest.efi             %Framework%\Test\ > NUL

   rem *********************************************

   rem Copy the UEFI 2.1 Test Cases for IHV

   rem *********************************************

diff --git a/uefi-sct/SctPkg/CommonGenFramework.sh b/uefi-sct/SctPkg/CommonGenFramework.sh
index c422034a..f0d1527b 100755
--- a/uefi-sct/SctPkg/CommonGenFramework.sh
+++ b/uefi-sct/SctPkg/CommonGenFramework.sh
@@ -312,7 +312,7 @@ then
   cp $ProcessorType/IhvUsb2HcTest.efi                        $Framework/Test/ > NUL
   cp $ProcessorType/IhviScsiInitiatorNameBBTest.efi          $Framework/Test/ > NUL
   cp $ProcessorType/IhvStorageSecurityCommandBBTest.efi      $Framework/Test/ > NUL
-
+  cp $ProcessorType/IhvHIIConfigAccessBBTest.efi             $Framework/Test/ > NUL
   # *********************************************
   # Copy the UEFI 2.1 Test Cases for IHV
   # *********************************************
diff --git a/uefi-sct/SctPkg/Config/Data/Category.ini b/uefi-sct/SctPkg/Config/Data/Category.ini
index 3e9f5e52..0bf8246e 100644
--- a/uefi-sct/SctPkg/Config/Data/Category.ini
+++ b/uefi-sct/SctPkg/Config/Data/Category.ini
@@ -479,6 +479,13 @@ InterfaceGuid = 330D4706-F2A0-4E4F-A369-B66FA8D54385
 Name          = HIITest\HIIConfigAccessProtocolTest

 Description   =

 

+[Category Data]

+Revision      = 0x00010000

+CategoryGuid  = 68820884-4BE3-4CA9-8381-9E98F3F48DAF

+InterfaceGuid = 330D4706-F2A0-4E4F-A369-B66FA8D54385

+Name          = IHV\HIITest\HIIConfigAccessProtocolTest

+Description   =

+

 [Category Data]

 Revision      = 0x00010000

 CategoryGuid  = 587E72D7-CC50-4F79-8209-CA291FC1A10F

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 00000000..6a6d4e60
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.c
@@ -0,0 +1,46 @@
+/** @file
+
+  Copyright 2006 - 2012 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2012, Intel Corporation. All rights reserved.<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 gHIIConfigAccessBBTestConformanceAssertionGuid008=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_008_GUID;
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid009=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_009_GUID;
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0010=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0010_GUID;
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0011=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0011_GUID;
+EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0012=EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0012_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/Guid.h b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h
new file mode 100644
index 00000000..b7003028
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/Guid.h
@@ -0,0 +1,109 @@
+/** @file
+
+  Copyright 2006 - 2011 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2011, Intel Corporation. All rights reserved.<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_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_008_GUID \
+{ 0xbdec5b08, 0x423, 0x482b, { 0xb7, 0xdf, 0xde, 0xac, 0xab, 0xf7, 0x13, 0x11 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid008;
+
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_009_GUID \
+{ 0x5fed024d, 0x85f3, 0x45bf, { 0xbe, 0xb1, 0xe4, 0xf4, 0xcc, 0x86, 0xe5, 0x61 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid009;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0010_GUID \
+{ 0x22ee938e, 0xa9ad, 0x4cb9, { 0x8d, 0x6d, 0x6, 0xe4, 0xfa, 0xb3, 0x72, 0xe7 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0010;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0011_GUID \
+{ 0x2053d3e0, 0xeebe, 0x4391, { 0x84, 0x7d, 0xf4, 0x60, 0x1b, 0x30, 0x4e, 0x3 } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0011;
+
+#define EFI_TEST_HIICONFIGACCESSBBTESTCONFORMANCE_ASSERTION_0012_GUID \
+{ 0x81c5d7b7, 0x7ebe, 0x44e1, { 0x8a, 0x1f, 0xcc, 0x47, 0x9c, 0x2d, 0xfe, 0x4f } }
+
+extern EFI_GUID gHIIConfigAccessBBTestConformanceAssertionGuid0012;
+*/
+
+#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/HIIConfigAccessBBTestConformance.c b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c
new file mode 100644
index 00000000..c8b35003
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestConformance.c
@@ -0,0 +1,908 @@
+/** @file
+
+  Copyright 2006 - 2016 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<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
+BBTestCallBackConformanceTestCheckpoint1 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  );
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint2 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  );
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint3 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  );
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint4 (
+  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;
+}
+
+/*
+EFI_STATUS
+BBTestCallBackConformanceTest (
+  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;
+
+  //
+  // 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;
+  }
+
+   //
+  //Call check points
+  //
+  BBTestCallBackConformanceTestCheckpoint1( StandardLib, HIIConfigAccess );
+  BBTestCallBackConformanceTestCheckpoint2( StandardLib, HIIConfigAccess );
+  BBTestCallBackConformanceTestCheckpoint3( StandardLib, HIIConfigAccess );
+  BBTestCallBackConformanceTestCheckpoint4( 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;
+}
+
+/*
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint1 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  )
+{
+  EFI_STATUS                                     Status;
+  EFI_TEST_ASSERTION                             AssertionType;
+
+  EFI_QUESTION_ID                                QuestionId;
+  UINT8                                          Type;
+  EFI_IFR_TYPE_VALUE                             Value;
+  EFI_BROWSER_ACTION_REQUEST                     ActionRequest;
+
+  //init the parameter
+  QuestionId=0x1234;
+  Type=EFI_IFR_TYPE_NUM_SIZE_8;
+
+ 
+  //
+  // Call CallBack with the Action been NULL
+  //
+  Status = HIIConfigAccess->CallBack (
+                  HIIConfigAccess,
+                  NULL,
+                  QuestionId,
+				  Type,
+				  &Value,
+				  &ActionRequest
+                  );
+
+  if ( EFI_INVALID_PARAMETER != Status ) {
+    AssertionType = EFI_TEST_ASSERTION_FAILED;
+  } else {
+    AssertionType = EFI_TEST_ASSERTION_PASSED;
+
+	//check the output ActionRequest
+  if ((EFI_BROWSER_ACTION_REQUEST_NONE || EFI_BROWSER_ACTION_REQUEST_RESET || EFI_BROWSER_ACTION_REQUEST_SUBMIT || EFI_BROWSER_ACTION_REQUEST_EXIT) != ActionRequest)
+	AssertionType = EFI_TEST_ASSERTION_FAILED;
+	
+  }
+  StandardLib->RecordAssertion (
+           StandardLib,
+           AssertionType,
+           gHIIConfigAccessBBTestConformanceAssertionGuid009,
+           L"HII_CONFIG_ACCESS_PROTOCOL.CallBack - CallBack() returns EFI_INVALID_PARAMETER with Action been NULL .",
+           L"%a:%d: Status - %r",
+           __FILE__,
+           (UINTN)__LINE__,
+           Status
+           );
+ return EFI_SUCCESS;
+
+}
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint2 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  )
+{
+  EFI_STATUS                                     Status;
+  EFI_TEST_ASSERTION                             AssertionType;
+
+  EFI_BROWSER_ACTION                             *Action;
+  EFI_QUESTION_ID                                QuestionId;
+  UINT8                                          Type;
+  EFI_IFR_TYPE_VALUE                             Value;
+
+
+  //init the parameter
+  Action=EFI_BROWSER_ACTION_REQUEST_CHANGING;
+  QuestionId=0x1234;
+  Type=EFI_IFR_TYPE_NUM_SIZE_8;
+
+ 
+  //
+  // Call CallBack with the ActionRequest been NULL
+  //
+  Status = HIIConfigAccess->CallBack (
+                  HIIConfigAccess,
+                  Action,
+                  QuestionId,
+				  Type,
+				  &Value,
+				  NULL
+                  );
+
+  if ( EFI_INVALID_PARAMETER != Status ) {
+    AssertionType = EFI_TEST_ASSERTION_FAILED;
+  } else {
+    AssertionType = EFI_TEST_ASSERTION_PASSED;
+	
+  }
+  StandardLib->RecordAssertion (
+           StandardLib,
+           AssertionType,
+           gHIIConfigAccessBBTestConformanceAssertionGuid0010,
+           L"HII_CONFIG_ACCESS_PROTOCOL.CallBack - CallBack() returns EFI_INVALID_PARAMETER with QuestionId been NULL.",
+           L"%a:%d: Status - %r",
+           __FILE__,
+           (UINTN)__LINE__,
+           Status
+           );
+ return EFI_SUCCESS;
+
+}
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint3(
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  )
+{
+  EFI_STATUS                                     Status;
+  EFI_TEST_ASSERTION                             AssertionType;
+
+  EFI_BROWSER_ACTION                             *Action;
+  EFI_QUESTION_ID                                QuestionId;
+  UINT8                                          Type;
+  EFI_BROWSER_ACTION_REQUEST                     ActionRequest;
+
+  //init the parameter
+  Action = EFI_BROWSER_ACTION_REQUEST_CHANGING;
+  QuestionId = 0x1234;
+  Type = EFI_IFR_TYPE_NUM_SIZE_8;
+
+ 
+  //
+  // Call CallBack with the Value been NULL
+  //
+  Status = HIIConfigAccess->CallBack (
+                  HIIConfigAccess,
+                  Action,
+                  QuestionId,
+				  Type,
+				  NULL,
+				  &ActionRequest
+                  );
+
+  if ( EFI_INVALID_PARAMETER != Status ) {
+    AssertionType = EFI_TEST_ASSERTION_FAILED;
+  } else {
+    AssertionType = EFI_TEST_ASSERTION_PASSED;
+	
+	//check the output ActionRequest
+  if ((EFI_BROWSER_ACTION_REQUEST_NONE || EFI_BROWSER_ACTION_REQUEST_RESET || EFI_BROWSER_ACTION_REQUEST_SUBMIT || EFI_BROWSER_ACTION_REQUEST_EXIT) != ActionRequest)
+	AssertionType = EFI_TEST_ASSERTION_FAILED;
+	
+  }
+  StandardLib->RecordAssertion (
+           StandardLib,
+           AssertionType,
+           gHIIConfigAccessBBTestConformanceAssertionGuid0011,
+           L"HII_CONFIG_ACCESS_PROTOCOL.CallBack - CallBack() returns EFI_INVALID_PARAMETER with Value been NULL.",
+           L"%a:%d: Status - %r",
+           __FILE__,
+           (UINTN)__LINE__,
+           Status
+           );
+ return EFI_SUCCESS;
+
+}
+
+EFI_STATUS
+BBTestCallBackConformanceTestCheckpoint4 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  )
+{
+  EFI_STATUS                                     Status;
+  EFI_TEST_ASSERTION                             AssertionType;
+
+  EFI_BROWSER_ACTION                             *Action;
+  EFI_QUESTION_ID                                QuestionId;
+  UINT8                                          Type;
+  EFI_IFR_TYPE_VALUE                             Value;
+  EFI_BROWSER_ACTION_REQUEST                     ActionRequest;
+
+  //init the parameter
+  Action=&EFI_BROWSER_ACTION_UNSUPPORTED;
+  QuestionId=0x1234;
+  Type=EFI_IFR_TYPE_NUM_SIZE_8;
+
+
+  //
+  // Call CallBack with  the specified action not supported by the callback
+  //
+  Status = HIIConfigAccess->CallBack (
+                  HIIConfigAccess,
+                  Action,
+                  QuestionId,
+				  Type,
+				  &Value,
+				  &ActionRequest
+                  );
+
+  if ( EFI_UNSUPPORTED != Status ) {
+    AssertionType = EFI_TEST_ASSERTION_FAILED;
+  } else {
+    AssertionType = EFI_TEST_ASSERTION_PASSED;
+	
+	//check the output ActionRequest
+  if ((EFI_BROWSER_ACTION_REQUEST_NONE || EFI_BROWSER_ACTION_REQUEST_RESET || EFI_BROWSER_ACTION_REQUEST_SUBMIT || EFI_BROWSER_ACTION_REQUEST_EXIT) != ActionRequest)
+	AssertionType = EFI_TEST_ASSERTION_FAILED;
+	
+  }
+  StandardLib->RecordAssertion (
+           StandardLib,
+           AssertionType,
+           gHIIConfigAccessBBTestConformanceAssertionGuid0012,
+           L"HII_CONFIG_ACCESS_PROTOCOL.CallBack - CallBack() returns EFI_ UNSUPPORTED with  the specified action not supported by the callback .",
+           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 00000000..14cc5684
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestFunction.c
@@ -0,0 +1,606 @@
+/** @file
+
+  Copyright 2006 - 2017 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved.<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
+  );
+/*
+EFI_STATUS
+BBTestCallBackFunctionTestCheckpoint1 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  );
+*/
+
+//
+//Test Cases
+//
+/*
+EFI_STATUS
+BBTestUnitTest (
+  IN EFI_BB_TEST_PROTOCOL       *This,
+  IN VOID                       *ClientInterface,
+  IN EFI_TEST_LEVEL             TestLevel,
+  IN EFI_HANDLE                 SupportHandle
+  )
+{
+  EFI_STATUS                            Status;
+  EFI_HII_CONFIG_ACCESS_PROTOCOL        *HIIConfigAccess;
+  EFI_STRING                            DevicePath = NULL;
+  EFI_STRING    Request = NULL;
+  EFI_STRING    Resp = NULL;
+  EFI_STRING    MultiConfigAltResp = L"GUID=970eb94aa0d449f7b980bdaa47d42527&NAME=ft894&PATH=000acf&OFFSET=3&WIDTH=4&VALUE=aabbccdd&OFFSET=1&WIDTH=2&VALUE=eeff&GUID=970eb94aa0d449f7b980bdaa47d42527&NAME=ft894&PATH=000acf&ALTCFG=0037&A000=abcd&B000=efef&GUID=970eb94aa0d449f7b980bdaa47d42528&NAME=ft894&PATH=0104180035170b0fa0879341b266538c38af48ce000000007fff0400&A000=abcd&B000=efef&GUID=970eb94aa0d449f7b980bdaa47d42528&NAME=ft894&PATH=0104180035170b0fa0879341b266538c38af48ce000000007fff0400&ALTCFG=0037&OFFSET=3&WIDTH=4&VALUE=aabbccdd&OFFSET=1&WIDTH=2&VALUE=eeff";;
+
+  //
+  // init
+  //
+  HIIConfigAccess = (EFI_HII_CONFIG_ACCESS_PROTOCOL*)ClientInterface;
+
+  Request = (EFI_STRING) SctAllocateZeroPool (2 * SctStrLen (MultiConfigAltResp) + 2);
+  if (Request == NULL)
+  	return EFI_OUT_OF_RESOURCES;
+
+  Resp = (EFI_STRING) SctAllocateZeroPool (2 * SctStrLen (MultiConfigAltResp) + 2);
+  if (Resp == NULL) {
+  	gtBS->FreePool (Request);
+  	return EFI_OUT_OF_RESOURCES;
+  }
+
+  Status = GetDevicePath ( HIIConfigAccess, &DevicePath );
+  if (EFI_ERROR(Status)) {
+    gtBS->FreePool (Resp);
+  	gtBS->FreePool (Request);
+    return Status;
+  }
+
+  Status = GetCorrespondingRequest (MultiConfigAltResp, DevicePath, Request);
+
+  Status = GetCorrespondingResp (MultiConfigAltResp, DevicePath, Resp);
+
+  gtBS->FreePool (Request);
+  gtBS->FreePool (Resp);
+  gtBS->FreePool (DevicePath);
+
+  return EFI_SUCCESS;
+}
+*/
+
+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;
+}
+
+/*
+EFI_STATUS
+BBTestCallBackFunctionTest (
+  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;
+
+  //
+  // 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;
+  }
+
+  //
+  //Call check points
+  //
+  BBTestCallBackFunctionTestCheckpoint1( StandardLib, 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;
+} 
+
+/*
+EFI_STATUS
+BBTestCallBackFunctionTestCheckpoint1 (
+  IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL         *StandardLib,
+  IN EFI_HII_CONFIG_ACCESS_PROTOCOL             *HIIConfigAccess
+  )
+{
+  EFI_STATUS                                     Status;
+  EFI_TEST_ASSERTION                             AssertionType;
+
+  EFI_BROWSER_ACTION                             *Action;
+  EFI_QUESTION_ID                                QuestionId;
+  UINT8                                          Type;
+  EFI_IFR_TYPE_VALUE                             Value;
+  EFI_BROWSER_ACTION_REQUEST                     ActionRequest;
+
+  //init the paremeters
+  Action=EFI_BROWSER_ACTION_REQUEST_CHANGING;
+  QuestionId=0x1234;
+  Type=EFI_IFR_TYPE_NUM_SIZE_8;
+
+
+  //
+  // Call CallBack  with valid parameters
+  //
+  Status = HIIConfigAccess->CallBack(
+                 HIIConfigAccess,
+                 Action,
+                 QuestionId,
+				 Type,
+				 &Value,
+				 &ActionRequest
+                 );
+  if ( EFI_SUCCESS != Status ) {
+    AssertionType = EFI_TEST_ASSERTION_FAILED;
+  } else {
+    AssertionType = EFI_TEST_ASSERTION_PASSED;
+	
+	//check the output ActionRequest
+  if ((EFI_BROWSER_ACTION_REQUEST_NONE || EFI_BROWSER_ACTION_REQUEST_RESET || EFI_BROWSER_ACTION_REQUEST_SUBMIT || EFI_BROWSER_ACTION_REQUEST_EXIT) != ActionRequest)
+	AssertionType = EFI_TEST_ASSERTION_FAILED;
+
+  }
+
+ 
+  StandardLib->RecordAssertion (
+           StandardLib,
+           AssertionType,
+           gHIIConfigAccessBBTestFunctionAssertionGuid003,
+           L"HII_CONFIG_ACCESS_PROTOCOL.CallBack- CallBack() returns EFI_SUCCESS with valid parameters .",
+           L"%a:%d: Status - %r",
+           __FILE__,
+           (UINTN)__LINE__,
+           Status
+           );
+  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 00000000..29c793e2
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.c
@@ -0,0 +1,655 @@
+/** @file
+
+  Copyright 2006 - 2016 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2016, Intel Corporation. All rights reserved.<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[] = {
+  /*
+  //Use for unit test only
+  {
+    { 0x8cdda816, 0x3f97, 0x4155, { 0xa6, 0x73, 0x86, 0x93, 0x79, 0x8f, 0xb0, 0x6d } },
+	L"Unit Test Only",
+	L"Verify the Assistant Function",
+    EFI_TEST_LEVEL_DEFAULT,
+    gSupportProtocolGuid,
+    EFI_TEST_CASE_AUTO,
+    BBTestUnitTest
+  },
+  */
+  {
+    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_GUID0103,
+    L"CallBackFunction",
+    L"Function auto test for HII Configuration Access Protocol CallBack().",
+    EFI_TEST_LEVEL_MINIMAL,
+    gSupportProtocolGuid,
+    EFI_TEST_CASE_AUTO,
+    BBTestCallBackFunctionTest
+  },
+  */
+  {
+    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
+  },
+  /*
+  {
+    EFI_HII_CONFIG_ACCESS_PROTOCOL_TEST_ENTRY_GUID0203,
+    L"CallBackConformance",
+    L"Conformance auto test for HII Configuration Access Protocol CallBack().",
+    EFI_TEST_LEVEL_MINIMAL,
+    gSupportProtocolGuid,
+    EFI_TEST_CASE_AUTO,
+    BBTestCallBackConformanceTest
+  },
+  */
+  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;
+}
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 00000000..c81a00ca
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/HIIConfigAccessBBTestMain.h
@@ -0,0 +1,168 @@
+/** @file
+
+  Copyright 2006 - 2013 Unified EFI, Inc.<BR>
+  Copyright (c) 2010 - 2013, Intel Corporation. All rights reserved.<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
+BBTestUnitTest (
+  IN EFI_BB_TEST_PROTOCOL       *This,
+  IN VOID                       *ClientInterface,
+  IN EFI_TEST_LEVEL             TestLevel,
+  IN EFI_HANDLE                 SupportHandle
+  );
+*/
+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
+BBTestCallBackConformanceTest (
+  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
+BBTestCallBackFunctionTest (
+  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/IhvHIIConfigAccessBBTest.inf b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf
new file mode 100644
index 00000000..1168986b
--- /dev/null
+++ b/uefi-sct/SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf
@@ -0,0 +1,55 @@
+## @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>
+#
+#  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/UEFI/IHV_SCT.dsc b/uefi-sct/SctPkg/UEFI/IHV_SCT.dsc
index 83396f1a..2d929ba2 100644
--- a/uefi-sct/SctPkg/UEFI/IHV_SCT.dsc
+++ b/uefi-sct/SctPkg/UEFI/IHV_SCT.dsc
@@ -210,6 +210,7 @@ SctPkg/TestCase/UEFI/IHV/Protocol/UsbIo/BlackBoxTest/IhvUsbIoTest.inf
 SctPkg/TestCase/UEFI/IHV/Protocol/GraphicsOutput/BlackBoxTest/IhvGraphicsOutputBBTest.inf

 SctPkg/TestCase/UEFI/IHV/Protocol/ExtScsiPassThru/BlackBoxTest/IhvExtScsiPassThruBBTest.inf

 SctPkg/TestCase/UEFI/IHV/Protocol/ScsiIo/BlackBoxTest/IhvScsiIoBBTest.inf

+SctPkg/TestCase/UEFI/IHV/Protocol/HIIConfigAccess/BlackBoxTest/IhvHIIConfigAccessBBTest.inf

 SctPkg/TestCase/UEFI/IHV/Protocol/iScsiInitiatorName/BlackBoxTest/IhviScsiInitiatorNameBBTest.inf

 

 SctPkg/TestCase/UEFI/IHV/Protocol/AbsolutePointer/BlackBoxTest/IhvAbsolutePointerBBTest.inf

-- 
2.22.0.windows.1






       reply	other threads:[~2019-07-17  3:37 UTC|newest]

Thread overview: 2+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
     [not found] <15B21220C2BCC530.20638@groups.io>
2019-07-17  3:37 ` Eric Jin [this message]
2019-07-17  3:12 [edk2-test][PATCH] Adding HII to IHVSCT shrishail

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=DA72DC7456565B47808A57108259571F637DD297@SHSMSX103.ccr.corp.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