VariableLockRequestToLockUnitTest.c

Go to the documentation of this file.

 
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#include <stddef.h>
#include <setjmp.h>
#include <cmocka.h>
 
#include <Uefi.h>
#include <Library/DebugLib.h>
#include <Library/BaseMemoryLib.h>
#include <Library/MemoryAllocationLib.h>
#include <Library/UnitTestLib.h>
#include <Library/VariablePolicyLib.h>
#include <Library/VariablePolicyHelperLib.h>
 
#include <Protocol/VariableLock.h>
 
#define UNIT_TEST_NAME     "VarPol/VarLock Shim Unit Test"
#define UNIT_TEST_VERSION  "1.0"
 
 
EFI_STATUS
EFIAPI
VariableLockRequestToLock (
  IN CONST EDKII_VARIABLE_LOCK_PROTOCOL  *This,
  IN       CHAR16                        *VariableName,
  IN       EFI_GUID                      *VendorGuid
  );
 
 
//
// Test GUID 1 {F955BA2D-4A2C-480C-BFD1-3CC522610592}
//
EFI_GUID  mTestGuid1 = {
  0xf955ba2d, 0x4a2c, 0x480c, { 0xbf, 0xd1, 0x3c, 0xc5, 0x22, 0x61, 0x5, 0x92 }
};
 
//
// Test GUID 2 {2DEA799E-5E73-43B9-870E-C945CE82AF3A}
//
EFI_GUID  mTestGuid2 = {
  0x2dea799e, 0x5e73, 0x43b9, { 0x87, 0xe, 0xc9, 0x45, 0xce, 0x82, 0xaf, 0x3a }
};
 
//
// Test GUID 3 {698A2BFD-A616-482D-B88C-7100BD6682A9}
//
EFI_GUID  mTestGuid3 = {
  0x698a2bfd, 0xa616, 0x482d, { 0xb8, 0x8c, 0x71, 0x0, 0xbd, 0x66, 0x82, 0xa9 }
};
 
#define TEST_VAR_1_NAME  L"TestVar1"
#define TEST_VAR_2_NAME  L"TestVar2"
#define TEST_VAR_3_NAME  L"TestVar3"
 
#define TEST_POLICY_ATTRIBUTES_NULL  0
#define TEST_POLICY_MIN_SIZE_NULL    0
#define TEST_POLICY_MAX_SIZE_NULL    MAX_UINT32
 
#define TEST_POLICY_MIN_SIZE_10   10
#define TEST_POLICY_MAX_SIZE_200  200
 
 
EFI_STATUS
EFIAPI
StubGetVariableNull (
  IN     CHAR16    *VariableName,
  IN     EFI_GUID  *VendorGuid,
  OUT    UINT32    *Attributes   OPTIONAL,
  IN OUT UINTN     *DataSize,
  OUT    VOID      *Data         OPTIONAL
  )
{
  UINT32      MockedAttr;
  UINTN       MockedDataSize;
  VOID        *MockedData;
  EFI_STATUS  MockedReturn;
 
  check_expected_ptr (VariableName);
  check_expected_ptr (VendorGuid);
  check_expected_ptr (DataSize);
 
  MockedAttr     = (UINT32)mock ();
  MockedDataSize = (UINTN)mock ();
  MockedData     = (VOID *)(UINTN)mock ();
  MockedReturn   = (EFI_STATUS)mock ();
 
  if (Attributes != NULL) {
    *Attributes = MockedAttr;
  }
 
  if ((Data != NULL) && !EFI_ERROR (MockedReturn)) {
    CopyMem (Data, MockedData, MockedDataSize);
  }
 
  *DataSize = MockedDataSize;
 
  return MockedReturn;
}
 
//
// Anything you think might be helpful that isn't a test itself.
//
 
STATIC
UNIT_TEST_STATUS
EFIAPI
LibInitMocked (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  return EFI_ERROR (InitVariablePolicyLib (StubGetVariableNull)) ? UNIT_TEST_ERROR_PREREQUISITE_NOT_MET : UNIT_TEST_PASSED;
}
 
STATIC
VOID
EFIAPI
LibCleanup (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  DeinitVariablePolicyLib ();
}
 
 
 
UNIT_TEST_STATUS
EFIAPI
LockingWithoutAnyPoliciesShouldSucceed (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS  Status;
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
LockingTwiceShouldSucceed (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS  Status;
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
LockingALockedVariableShouldSucceed (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS             Status;
  VARIABLE_POLICY_ENTRY  *NewEntry;
 
  //
  // Create a variable policy that locks the variable.
  //
  Status = CreateBasicVariablePolicy (
             &mTestGuid1,
             TEST_VAR_1_NAME,
             TEST_POLICY_MIN_SIZE_NULL,
             TEST_POLICY_MAX_SIZE_200,
             TEST_POLICY_ATTRIBUTES_NULL,
             TEST_POLICY_ATTRIBUTES_NULL,
             VARIABLE_POLICY_TYPE_LOCK_NOW,
             &NewEntry
             );
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  //
  // Register the new policy.
  //
  Status = RegisterVariablePolicy (NewEntry);
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  FreePool (NewEntry);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
LockingAnUnlockedVariableShouldFail (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS             Status;
  VARIABLE_POLICY_ENTRY  *NewEntry;
 
  // Create a variable policy that locks the variable.
  Status = CreateVarStateVariablePolicy (
             &mTestGuid1,
             TEST_VAR_1_NAME,
             TEST_POLICY_MIN_SIZE_NULL,
             TEST_POLICY_MAX_SIZE_200,
             TEST_POLICY_ATTRIBUTES_NULL,
             TEST_POLICY_ATTRIBUTES_NULL,
             &mTestGuid2,
             1,
             TEST_VAR_2_NAME,
             &NewEntry
             );
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  // Register the new policy.
  Status = RegisterVariablePolicy (NewEntry);
 
  // Configure the stub to not care about parameters. We're testing errors.
  expect_any_always (StubGetVariableNull, VariableName);
  expect_any_always (StubGetVariableNull, VendorGuid);
  expect_any_always (StubGetVariableNull, DataSize);
 
  // With a policy, make sure that writes still work, since the variable doesn't exist.
  will_return (StubGetVariableNull, TEST_POLICY_ATTRIBUTES_NULL);     // Attributes
  will_return (StubGetVariableNull, 0);                               // Size
  will_return (StubGetVariableNull, (UINTN)NULL);                     // DataPtr
  will_return (StubGetVariableNull, EFI_NOT_FOUND);                   // Status
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_TRUE (EFI_ERROR (Status));
 
  FreePool (NewEntry);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
LockingALockedVariableWithMatchingDataShouldSucceed (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS             Status;
  VARIABLE_POLICY_ENTRY  *NewEntry;
  UINT8                  Data;
 
  // Create a variable policy that locks the variable.
  Status = CreateVarStateVariablePolicy (
             &mTestGuid1,
             TEST_VAR_1_NAME,
             TEST_POLICY_MIN_SIZE_NULL,
             TEST_POLICY_MAX_SIZE_200,
             TEST_POLICY_ATTRIBUTES_NULL,
             TEST_POLICY_ATTRIBUTES_NULL,
             &mTestGuid2,
             1,
             TEST_VAR_2_NAME,
             &NewEntry
             );
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  // Register the new policy.
  Status = RegisterVariablePolicy (NewEntry);
 
  // Configure the stub to not care about parameters. We're testing errors.
  expect_any_always (StubGetVariableNull, VariableName);
  expect_any_always (StubGetVariableNull, VendorGuid);
  expect_any_always (StubGetVariableNull, DataSize);
 
  // With a policy, make sure that writes still work, since the variable doesn't exist.
  Data = 1;
  will_return (StubGetVariableNull, TEST_POLICY_ATTRIBUTES_NULL);     // Attributes
  will_return (StubGetVariableNull, sizeof (Data));                   // Size
  will_return (StubGetVariableNull, (UINTN)&Data);                    // DataPtr
  will_return (StubGetVariableNull, EFI_SUCCESS);                     // Status
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_TRUE (!EFI_ERROR (Status));
 
  FreePool (NewEntry);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
LockingALockedVariableWithNonMatchingDataShouldFail (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS             Status;
  VARIABLE_POLICY_ENTRY  *NewEntry;
  UINT8                  Data;
 
  // Create a variable policy that locks the variable.
  Status = CreateVarStateVariablePolicy (
             &mTestGuid1,
             TEST_VAR_1_NAME,
             TEST_POLICY_MIN_SIZE_NULL,
             TEST_POLICY_MAX_SIZE_200,
             TEST_POLICY_ATTRIBUTES_NULL,
             TEST_POLICY_ATTRIBUTES_NULL,
             &mTestGuid2,
             1,
             TEST_VAR_2_NAME,
             &NewEntry
             );
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  // Register the new policy.
  Status = RegisterVariablePolicy (NewEntry);
 
  // Configure the stub to not care about parameters. We're testing errors.
  expect_any_always (StubGetVariableNull, VariableName);
  expect_any_always (StubGetVariableNull, VendorGuid);
  expect_any_always (StubGetVariableNull, DataSize);
 
  // With a policy, make sure that writes still work, since the variable doesn't exist.
  Data = 2;
  will_return (StubGetVariableNull, TEST_POLICY_ATTRIBUTES_NULL);     // Attributes
  will_return (StubGetVariableNull, sizeof (Data));                   // Size
  will_return (StubGetVariableNull, (UINTN)&Data);                    // DataPtr
  will_return (StubGetVariableNull, EFI_SUCCESS);                     // Status
 
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_TRUE (EFI_ERROR (Status));
 
  FreePool (NewEntry);
 
  return UNIT_TEST_PASSED;
}
 
UNIT_TEST_STATUS
EFIAPI
SettingPolicyForALockedVariableShouldFail (
  IN UNIT_TEST_CONTEXT  Context
  )
{
  EFI_STATUS             Status;
  VARIABLE_POLICY_ENTRY  *NewEntry;
 
  // Lock the variable.
  Status = VariableLockRequestToLock (NULL, TEST_VAR_1_NAME, &mTestGuid1);
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  // Create a variable policy that locks the variable.
  Status = CreateVarStateVariablePolicy (
             &mTestGuid1,
             TEST_VAR_1_NAME,
             TEST_POLICY_MIN_SIZE_NULL,
             TEST_POLICY_MAX_SIZE_200,
             TEST_POLICY_ATTRIBUTES_NULL,
             TEST_POLICY_ATTRIBUTES_NULL,
             &mTestGuid2,
             1,
             TEST_VAR_2_NAME,
             &NewEntry
             );
  UT_ASSERT_NOT_EFI_ERROR (Status);
 
  // Register the new policy.
  Status = RegisterVariablePolicy (NewEntry);
  UT_ASSERT_TRUE (EFI_ERROR (Status));
 
  FreePool (NewEntry);
 
  return UNIT_TEST_PASSED;
}
 
VOID
EFIAPI
UnitTestMain (
  VOID
  )
{
  EFI_STATUS                  Status;
  UNIT_TEST_FRAMEWORK_HANDLE  Framework;
  UNIT_TEST_SUITE_HANDLE      ShimTests;
 
  Framework = NULL;
 
  DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));
 
  //
  // Start setting up the test framework for running the tests.
  //
  Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));
    goto EXIT;
  }
 
  //
  // Add all test suites and tests.
  //
  Status = CreateUnitTestSuite (
             &ShimTests,
             Framework,
             "Variable Lock Shim Tests",
             "VarPolicy.VarLockShim",
             NULL,
             NULL
             );
  if (EFI_ERROR (Status)) {
    DEBUG ((DEBUG_ERROR, "Failed in CreateUnitTestSuite for ShimTests\n"));
    Status = EFI_OUT_OF_RESOURCES;
    goto EXIT;
  }
 
  AddTestCase (
    ShimTests,
    "Locking a variable with no matching policies should always work",
    "EmptyPolicies",
    LockingWithoutAnyPoliciesShouldSucceed,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Locking a variable twice should always work",
    "DoubleLock",
    LockingTwiceShouldSucceed,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Locking a variable that's already locked by another policy should work",
    "LockAfterPolicy",
    LockingALockedVariableShouldSucceed,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Locking a variable that already has an unlocked policy should fail",
    "LockAfterUnlockedPolicy",
    LockingAnUnlockedVariableShouldFail,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Locking a variable that already has an locked policy should succeed",
    "LockAfterLockedPolicyMatchingData",
    LockingALockedVariableWithMatchingDataShouldSucceed,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Locking a variable that already has an locked policy with matching data should succeed",
    "LockAfterLockedPolicyNonMatchingData",
    LockingALockedVariableWithNonMatchingDataShouldFail,
    LibInitMocked,
    LibCleanup,
    NULL
    );
  AddTestCase (
    ShimTests,
    "Adding a policy for a variable that has previously been locked should always fail",
    "SetPolicyAfterLock",
    SettingPolicyForALockedVariableShouldFail,
    LibInitMocked,
    LibCleanup,
    NULL
    );
 
  //
  // Execute the tests.
  //
  Status = RunAllTestSuites (Framework);
 
EXIT:
  if (Framework != NULL) {
    FreeUnitTestFramework (Framework);
  }
 
  return;
}
 
#define Main  main
 
INT32
Main (
  IN INT32  Argc,
  IN CHAR8  *Argv[]
  )
{
  UnitTestMain ();
  return 0;
}