MdePkg/Test/BaseLib: Add SAFE_STRING_CONSTRAINT_CHECK unit test

[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
        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
        UT_LOG_ERROR ("\n");\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
        UT_LOG_ERROR ("\nBinData:\n");\r
        for (indx = 0; indx < ReturnSize; indx++) {\r
          UT_LOG_ERROR (" %2.2x", 0xff & BinData[indx]);\r
        }\r
        UT_LOG_ERROR ("\n");\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