[mirror_edk2.git] / MdePkg / Test / UnitTest / Library / BaseLib / Base64UnitTest.c

/** @file\r
  Unit tests of Base64 conversion APIs in BaseLib.\r
\r
  Copyright (C) Microsoft Corporation.\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include <Uefi.h>\r
#include <Library/BaseLib.h>\r
#include <Library/BaseMemoryLib.h>\r
#include <Library/DebugLib.h>\r
#include <Library/MemoryAllocationLib.h>\r
#include <Library/UnitTestLib.h>\r
\r
#define UNIT_TEST_APP_NAME     "BaseLib Unit Test Application"\r
#define UNIT_TEST_APP_VERSION  "1.0"\r
\r
/**\r
  RFC 4648  https://tools.ietf.org/html/rfc4648 test vectors\r
\r
  BASE64("") = ""\r
  BASE64("f") = "Zg=="\r
  BASE64("fo") = "Zm8="\r
  BASE64("foo") = "Zm9v"\r
  BASE64("foob") = "Zm9vYg=="\r
  BASE64("fooba") = "Zm9vYmE="\r
  BASE64("foobar") = "Zm9vYmFy"\r
\r
  The test vectors are using ascii strings for the binary data\r
 */\r
\r
typedef struct {\r
  CHAR8         *TestInput;\r
  CHAR8         *TestOutput;\r
  EFI_STATUS    ExpectedStatus;\r
  VOID          *BufferToFree;\r
  UINTN         ExpectedSize;\r
} BASIC_TEST_CONTEXT;\r
\r
#define B64_TEST_1  ""\r
#define BIN_TEST_1  ""\r
\r
#define B64_TEST_2  "Zg=="\r
#define BIN_TEST_2  "f"\r
\r
#define B64_TEST_3  "Zm8="\r
#define BIN_TEST_3  "fo"\r
\r
#define B64_TEST_4  "Zm9v"\r
#define BIN_TEST_4  "foo"\r
\r
#define B64_TEST_5  "Zm9vYg=="\r
#define BIN_TEST_5  "foob"\r
\r
#define B64_TEST_6  "Zm9vYmE="\r
#define BIN_TEST_6  "fooba"\r
\r
#define B64_TEST_7  "Zm9vYmFy"\r
#define BIN_TEST_7  "foobar"\r
\r
// Adds all white space - also ends the last quantum with only spaces afterwards\r
#define B64_TEST_8_IN  " \t\v  Zm9\r\nvYmFy \f  "\r
#define BIN_TEST_8     "foobar"\r
\r
// Not a quantum multiple of 4\r
#define B64_ERROR_1  "Zm9vymFy="\r
\r
// Invalid characters in the string\r
#define B64_ERROR_2  "Zm$vymFy"\r
\r
// Too many '=' characters\r
#define B64_ERROR_3  "Z==="\r
\r
// Poorly placed '='\r
#define B64_ERROR_4  "Zm=vYmFy"\r
\r
#define MAX_TEST_STRING_SIZE  (200)\r
\r
// ------------------------------------------------ Input----------Output-----------Result-------Free--Expected Output Size\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest1  = { BIN_TEST_1, B64_TEST_1, EFI_SUCCESS, NULL, sizeof (B64_TEST_1) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest2  = { BIN_TEST_2, B64_TEST_2, EFI_SUCCESS, NULL, sizeof (B64_TEST_2) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest3  = { BIN_TEST_3, B64_TEST_3, EFI_SUCCESS, NULL, sizeof (B64_TEST_3) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest4  = { BIN_TEST_4, B64_TEST_4, EFI_SUCCESS, NULL, sizeof (B64_TEST_4) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest5  = { BIN_TEST_5, B64_TEST_5, EFI_SUCCESS, NULL, sizeof (B64_TEST_5) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest6  = { BIN_TEST_6, B64_TEST_6, EFI_SUCCESS, NULL, sizeof (B64_TEST_6) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeTest7  = { BIN_TEST_7, B64_TEST_7, EFI_SUCCESS, NULL, sizeof (B64_TEST_7) };\r
static BASIC_TEST_CONTEXT  mBasicEncodeError1 = { BIN_TEST_7, B64_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof (B64_TEST_7) };\r
\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest1 = { B64_TEST_1, BIN_TEST_1, EFI_SUCCESS, NULL, sizeof (BIN_TEST_1)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest2 = { B64_TEST_2, BIN_TEST_2, EFI_SUCCESS, NULL, sizeof (BIN_TEST_2)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest3 = { B64_TEST_3, BIN_TEST_3, EFI_SUCCESS, NULL, sizeof (BIN_TEST_3)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest4 = { B64_TEST_4, BIN_TEST_4, EFI_SUCCESS, NULL, sizeof (BIN_TEST_4)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest5 = { B64_TEST_5, BIN_TEST_5, EFI_SUCCESS, NULL, sizeof (BIN_TEST_5)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest6 = { B64_TEST_6, BIN_TEST_6, EFI_SUCCESS, NULL, sizeof (BIN_TEST_6)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest7 = { B64_TEST_7, BIN_TEST_7, EFI_SUCCESS, NULL, sizeof (BIN_TEST_7)-1 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeTest8 = { B64_TEST_8_IN, BIN_TEST_8, EFI_SUCCESS, NULL, sizeof (BIN_TEST_8)-1 };\r
\r
static BASIC_TEST_CONTEXT  mBasicDecodeError1 = { B64_ERROR_1, B64_ERROR_1, EFI_INVALID_PARAMETER, NULL, 0 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeError2 = { B64_ERROR_2, B64_ERROR_2, EFI_INVALID_PARAMETER, NULL, 0 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeError3 = { B64_ERROR_3, B64_ERROR_3, EFI_INVALID_PARAMETER, NULL, 0 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeError4 = { B64_ERROR_4, B64_ERROR_4, EFI_INVALID_PARAMETER, NULL, 0 };\r
static BASIC_TEST_CONTEXT  mBasicDecodeError5 = { B64_TEST_7, BIN_TEST_1, EFI_BUFFER_TOO_SMALL, NULL, sizeof (BIN_TEST_7)-1 };\r
\r
/**\r
  Simple clean up method to make sure tests clean up even if interrupted and fail\r
  in the middle.\r
**/\r
STATIC\r
VOID\r
EFIAPI\r
CleanUpB64TestContext (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  BASIC_TEST_CONTEXT  *Btc;\r
\r
  Btc = (BASIC_TEST_CONTEXT *)Context;\r
  if (Btc != NULL) {\r
    // free string if set\r
    if (Btc->BufferToFree != NULL) {\r
      FreePool (Btc->BufferToFree);\r
      Btc->BufferToFree = NULL;\r
    }\r
  }\r
}\r
\r
/**\r
  Unit test for Base64 encode APIs of BaseLib.\r
\r
  @param[in]  Context    [Optional] An optional parameter that enables:\r
                         1) test-case reuse with varied parameters and\r
                         2) test-case re-entry for Target tests that need a\r
                         reboot.  This parameter is a VOID* and it is the\r
                         responsibility of the test author to ensure that the\r
                         contents are well understood by all test cases that may\r
                         consume it.\r
\r
  @retval  UNIT_TEST_PASSED             The Unit test has completed and the test\r
                                        case was successful.\r
  @retval  UNIT_TEST_ERROR_TEST_FAILED  A test case assertion has failed.\r
**/\r
STATIC\r
UNIT_TEST_STATUS\r
EFIAPI\r
RfcEncodeTest (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  BASIC_TEST_CONTEXT  *Btc;\r
  CHAR8               *b64String;\r
  CHAR8               *binString;\r
  UINTN               b64StringSize;\r
  EFI_STATUS          Status;\r
  UINT8               *BinData;\r
  UINTN               BinSize;\r
  CHAR8               *b64WorkString;\r
  UINTN               ReturnSize;\r
  INTN                CompareStatus;\r
  UINTN               indx;\r
\r
  Btc       = (BASIC_TEST_CONTEXT *)Context;\r
  binString = Btc->TestInput;\r
  b64String = Btc->TestOutput;\r
\r
  //\r
  // Only testing the the translate functionality, so preallocate the proper\r
  // string buffer.\r
  //\r
\r
  b64StringSize = AsciiStrnSizeS (b64String, MAX_TEST_STRING_SIZE);\r
  BinSize       = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);\r
  BinData       = (UINT8 *)binString;\r
\r
  b64WorkString = (CHAR8 *)AllocatePool (b64StringSize);\r
  UT_ASSERT_NOT_NULL (b64WorkString);\r
\r
  Btc->BufferToFree = b64WorkString;\r
  ReturnSize        = b64StringSize;\r
\r
  Status = Base64Encode (BinData, BinSize, b64WorkString, &ReturnSize);\r
\r
  UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);\r
\r
  UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);\r
\r
  if (!EFI_ERROR (Btc->ExpectedStatus)) {\r
    if (ReturnSize != 0) {\r
      CompareStatus = AsciiStrnCmp (b64String, b64WorkString, ReturnSize);\r
      if (CompareStatus != 0) {\r
        UT_LOG_ERROR ("b64 string compare error - size=%d\n", ReturnSize);\r
        for (indx = 0; indx < ReturnSize; indx++) {\r
          UT_LOG_ERROR (" %2.2x", 0xff & b64String[indx]);\r
        }\r
\r
        UT_LOG_ERROR ("\n b64 work string:\n");\r
        for (indx = 0; indx < ReturnSize; indx++) {\r
          UT_LOG_ERROR (" %2.2x", 0xff & b64WorkString[indx]);\r
        }\r
\r
        UT_LOG_ERROR ("\n");\r
      }\r
\r
      UT_ASSERT_EQUAL (CompareStatus, 0);\r
    }\r
  }\r
\r
  Btc->BufferToFree = NULL;\r
  FreePool (b64WorkString);\r
  return UNIT_TEST_PASSED;\r
}\r
\r
/**\r
  Unit test for Base64 decode APIs of BaseLib.\r
\r
  @param[in]  Context    [Optional] An optional parameter that enables:\r
                         1) test-case reuse with varied parameters and\r
                         2) test-case re-entry for Target tests that need a\r
                         reboot.  This parameter is a VOID* and it is the\r
                         responsibility of the test author to ensure that the\r
                         contents are well understood by all test cases that may\r
                         consume it.\r
\r
  @retval  UNIT_TEST_PASSED             The Unit test has completed and the test\r
                                        case was successful.\r
  @retval  UNIT_TEST_ERROR_TEST_FAILED  A test case assertion has failed.\r
**/\r
STATIC\r
UNIT_TEST_STATUS\r
EFIAPI\r
RfcDecodeTest (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  BASIC_TEST_CONTEXT  *Btc;\r
  CHAR8               *b64String;\r
  CHAR8               *binString;\r
  EFI_STATUS          Status;\r
  UINTN               b64StringLen;\r
  UINTN               ReturnSize;\r
  UINT8               *BinData;\r
  UINTN               BinSize;\r
  INTN                CompareStatus;\r
  UINTN               indx;\r
\r
  Btc       = (BASIC_TEST_CONTEXT *)Context;\r
  b64String = Btc->TestInput;\r
  binString = Btc->TestOutput;\r
\r
  //\r
  //  Only testing the the translate functionality\r
  //\r
\r
  b64StringLen = AsciiStrnLenS (b64String, MAX_TEST_STRING_SIZE);\r
  BinSize      = AsciiStrnLenS (binString, MAX_TEST_STRING_SIZE);\r
\r
  BinData = AllocatePool (BinSize);\r
  UT_ASSERT_NOT_NULL (BinData);\r
\r
  Btc->BufferToFree = BinData;\r
  ReturnSize        = BinSize;\r
\r
  Status = Base64Decode (b64String, b64StringLen, BinData, &ReturnSize);\r
\r
  UT_ASSERT_STATUS_EQUAL (Status, Btc->ExpectedStatus);\r
\r
  // If an error is not expected, check the results\r
  if (EFI_ERROR (Btc->ExpectedStatus)) {\r
    if (Btc->ExpectedStatus == EFI_BUFFER_TOO_SMALL) {\r
      UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);\r
    }\r
  } else {\r
    UT_ASSERT_EQUAL (ReturnSize, Btc->ExpectedSize);\r
    if (ReturnSize != 0) {\r
      CompareStatus = CompareMem (binString, BinData, ReturnSize);\r
      if (CompareStatus != 0) {\r
        UT_LOG_ERROR ("bin string compare error - size=%d\n", ReturnSize);\r
        for (indx = 0; indx < ReturnSize; indx++) {\r
          UT_LOG_ERROR (" %2.2x", 0xff & binString[indx]);\r
        }\r
\r
        UT_LOG_ERROR ("\nBinData:\n");\r
        for (indx = 0; indx < ReturnSize; indx++) {\r
          UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);\r
        }\r
\r
        UT_LOG_ERROR ("\n");\r
      }\r
\r
      UT_ASSERT_EQUAL (CompareStatus, 0);\r
    }\r
  }\r
\r
  Btc->BufferToFree = NULL;\r
  FreePool (BinData);\r
  return UNIT_TEST_PASSED;\r
}\r
\r
#define SOURCE_STRING  L"Hello"\r
\r
STATIC\r
UNIT_TEST_STATUS\r
EFIAPI\r
SafeStringContraintCheckTest (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  RETURN_STATUS  Status;\r
  CHAR16         Destination[20];\r
  CHAR16         AllZero[20];\r
\r
  //\r
  // Zero buffer used to verify Destination is not modified\r
  //\r
  ZeroMem (AllZero, sizeof (AllZero));\r
\r
  //\r
  // Positive test case copy source unicode string to destination\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, sizeof (Destination) / sizeof (CHAR16), SOURCE_STRING);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_MEM_EQUAL (Destination, SOURCE_STRING, sizeof (SOURCE_STRING));\r
\r
  //\r
  // Positive test case with DestMax the same as Source size\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, sizeof (SOURCE_STRING) / sizeof (CHAR16), SOURCE_STRING);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_MEM_EQUAL (Destination, SOURCE_STRING, sizeof (SOURCE_STRING));\r
\r
  //\r
  // Negative test case with Destination NULL\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (NULL, sizeof (Destination) / sizeof (CHAR16), SOURCE_STRING);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_INVALID_PARAMETER);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with Source NULL\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, sizeof (Destination) / sizeof (CHAR16), NULL);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_INVALID_PARAMETER);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with DestMax too big\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, MAX_UINTN, SOURCE_STRING);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_INVALID_PARAMETER);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with DestMax 0\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, 0, SOURCE_STRING);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_INVALID_PARAMETER);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with DestMax smaller than Source size\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, 1, SOURCE_STRING);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_BUFFER_TOO_SMALL);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with DestMax smaller than Source size by one character\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, sizeof (SOURCE_STRING) / sizeof (CHAR16) - 1, SOURCE_STRING);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_BUFFER_TOO_SMALL);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  //\r
  // Negative test case with overlapping Destination and Source\r
  //\r
  ZeroMem (Destination, sizeof (Destination));\r
  Status = StrCpyS (Destination, sizeof (Destination) / sizeof (CHAR16), Destination);\r
  UT_ASSERT_STATUS_EQUAL (Status, RETURN_ACCESS_DENIED);\r
  UT_ASSERT_MEM_EQUAL (Destination, AllZero, sizeof (AllZero));\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
/**\r
  Initialze the unit test framework, suite, and unit tests for the\r
  Base64 conversion APIs of BaseLib and run the unit tests.\r
\r
  @retval  EFI_SUCCESS           All test cases were dispatched.\r
  @retval  EFI_OUT_OF_RESOURCES  There are not enough resources available to\r
                                 initialize the unit tests.\r
**/\r
STATIC\r
EFI_STATUS\r
EFIAPI\r
UnitTestingEntry (\r
  VOID\r
  )\r
{\r
  EFI_STATUS                  Status;\r
  UNIT_TEST_FRAMEWORK_HANDLE  Fw;\r
  UNIT_TEST_SUITE_HANDLE      b64EncodeTests;\r
  UNIT_TEST_SUITE_HANDLE      b64DecodeTests;\r
  UNIT_TEST_SUITE_HANDLE      SafeStringTests;\r
\r
  Fw = NULL;\r
\r
  DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_APP_NAME, UNIT_TEST_APP_VERSION));\r
\r
  //\r
  // Start setting up the test framework for running the tests.\r
  //\r
  Status = InitUnitTestFramework (&Fw, UNIT_TEST_APP_NAME, gEfiCallerBaseName, UNIT_TEST_APP_VERSION);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));\r
    goto EXIT;\r
  }\r
\r
  //\r
  // Populate the B64 Encode Unit Test Suite.\r
  //\r
  Status = CreateUnitTestSuite (&b64EncodeTests, Fw, "b64 Encode binary to Ascii string", "BaseLib.b64Encode", NULL, NULL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64EncodeTests\n"));\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto EXIT;\r
  }\r
\r
  // --------------Suite-----------Description--------------Class Name----------Function--------Pre---Post-------------------Context-----------\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest1);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - f", "Test2", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest2);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest3);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest4);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest5);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest6);\r
  AddTestCase (b64EncodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeTest7);\r
  AddTestCase (b64EncodeTests, "Too small of output buffer", "Error1", RfcEncodeTest, NULL, CleanUpB64TestContext, &mBasicEncodeError1);\r
  //\r
  // Populate the B64 Decode Unit Test Suite.\r
  //\r
  Status = CreateUnitTestSuite (&b64DecodeTests, Fw, "b64 Decode Ascii string to binary", "BaseLib.b64Decode", NULL, NULL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for b64Decode Tests\n"));\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto EXIT;\r
  }\r
\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - Empty", "Test1", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest1);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - f", "Test2", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest2);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fo", "Test3", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest3);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foo", "Test4", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest4);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foob", "Test5", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest5);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - fooba", "Test6", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest6);\r
  AddTestCase (b64DecodeTests, "RFC 4686 Test Vector - foobar", "Test7", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest7);\r
  AddTestCase (b64DecodeTests, "Ignore Whitespace test", "Test8", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeTest8);\r
\r
  AddTestCase (b64DecodeTests, "Not a quantum multiple of 4", "Error1", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError1);\r
  AddTestCase (b64DecodeTests, "Invalid characters in the string", "Error2", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError2);\r
  AddTestCase (b64DecodeTests, "Too many padding characters", "Error3", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError3);\r
  AddTestCase (b64DecodeTests, "Incorrectly placed padding character", "Error4", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError4);\r
  AddTestCase (b64DecodeTests, "Too small of output buffer", "Error5", RfcDecodeTest, NULL, CleanUpB64TestContext, &mBasicDecodeError5);\r
\r
  //\r
  // Populate the safe string Unit Test Suite.\r
  //\r
  Status = CreateUnitTestSuite (&SafeStringTests, Fw, "Safe String", "BaseLib.SafeString", NULL, NULL);\r
  if (EFI_ERROR (Status)) {\r
    DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for SafeStringTests\n"));\r
    Status = EFI_OUT_OF_RESOURCES;\r
    goto EXIT;\r
  }\r
\r
  // --------------Suite-----------Description--------------Class Name----------Function--------Pre---Post-------------------Context-----------\r
  AddTestCase (SafeStringTests, "SAFE_STRING_CONSTRAINT_CHECK", "SafeStringContraintCheckTest", SafeStringContraintCheckTest, NULL, NULL, NULL);\r
\r
  //\r
  // Execute the tests.\r
  //\r
  Status = RunAllTestSuites (Fw);\r
\r
EXIT:\r
  if (Fw) {\r
    FreeUnitTestFramework (Fw);\r
  }\r
\r
  return Status;\r
}\r
\r
/**\r
  Standard UEFI entry point for target based unit test execution from UEFI Shell.\r
**/\r
EFI_STATUS\r
EFIAPI\r
BaseLibUnitTestAppEntry (\r
  IN EFI_HANDLE        ImageHandle,\r
  IN EFI_SYSTEM_TABLE  *SystemTable\r
  )\r
{\r
  return UnitTestingEntry ();\r
}\r
\r
/**\r
  Standard POSIX C entry point for host based unit test execution.\r
**/\r
int\r
main (\r
  int   argc,\r
  char  *argv[]\r
  )\r
{\r
  return UnitTestingEntry ();\r
}\r