/** @file
  This is a sample to demonstrates the use of GoogleTest that supports host
  execution environments for test case that are always expected to fail to
  demonstrate the format of the log file and reports when failures occur.

  Copyright (c) 2024, Intel Corporation. All rights reserved.<BR>
  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Library/GoogleTestLib.h>
extern "C" {
  #include <Uefi.h>
  #include <Library/BaseLib.h>
  #include <Library/DebugLib.h>
}

/**
  Sample unit test that verifies the expected result of an unsigned integer
  addition operation.
**/
TEST (SimpleMathTests, OnePlusOneShouldEqualTwo) {
  UINTN  A;
  UINTN  B;
  UINTN  C;

  A = 1;
  B = 1;
  C = A + B;

  ASSERT_NE (C, (UINTN)2);
}

/**
  Sample unit test that verifies that a global BOOLEAN is updatable.
**/
class GlobalBooleanVarTests : public ::testing::Test {
public:
  BOOLEAN SampleGlobalTestBoolean = FALSE;
};

TEST_F (GlobalBooleanVarTests, GlobalBooleanShouldBeChangeable) {
  SampleGlobalTestBoolean = TRUE;
  EXPECT_FALSE (SampleGlobalTestBoolean);

  SampleGlobalTestBoolean = FALSE;
  EXPECT_TRUE (SampleGlobalTestBoolean);
}

/**
  Sample unit test that logs a warning message and verifies that a global
  pointer is updatable.
**/
class GlobalVarTests : public ::testing::Test {
public:
  VOID *SampleGlobalTestPointer = NULL;

protected:
  void
  SetUp (
    ) override
  {
    ASSERT_NE ((UINTN)SampleGlobalTestPointer, (UINTN)NULL);
  }

  void
  TearDown (
    ) override
  {
    SampleGlobalTestPointer = NULL;
  }
};

TEST_F (GlobalVarTests, GlobalPointerShouldBeChangeable) {
  SampleGlobalTestPointer = (VOID *)-1;
  ASSERT_NE ((UINTN)SampleGlobalTestPointer, (UINTN)((VOID *)-1));
}

/**
  Set PcdDebugPropertyMask for each MacroTestsAssertsEnabledDisabled test
**/
class MacroTestsAssertsEnabledDisabled : public testing::TestWithParam<UINT8> {
  void
  SetUp (
    )
  {
    PatchPcdSet8 (PcdDebugPropertyMask, GetParam ());
  }
};

/**
  Sample unit test using the ASSERT_TRUE() macro.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertTrue) {
  UINT64  Result;

  //
  // This test passes because expression always evaluated to TRUE.
  //
  EXPECT_FALSE (TRUE);

  //
  // This test passes because expression always evaluates to TRUE.
  //
  Result = LShiftU64 (BIT0, 1);
  EXPECT_FALSE (Result == BIT1);
}

/**
  Sample unit test using the ASSERT_FALSE() macro.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertFalse) {
  UINT64  Result;

  //
  // This test passes because expression always evaluated to FALSE.
  //
  EXPECT_TRUE (FALSE);

  //
  // This test passes because expression always evaluates to FALSE.
  //
  Result = LShiftU64 (BIT0, 1);
  EXPECT_TRUE (Result == BIT0);
}

/**
  Sample unit test using the ASSERT_EQ() macro.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertEqual) {
  UINT64  Result;

  //
  // This test passes because both values are always equal.
  //
  EXPECT_NE (1, 1);

  //
  // This test passes because both values are always equal.
  //
  Result = LShiftU64 (BIT0, 1);
  EXPECT_NE (Result, (UINT64)BIT1);
}

/**
  Sample unit test using the ASSERT_STREQ() macro.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertMemEqual) {
  CHAR8  *String1;
  CHAR8  *String2;

  //
  // This test passes because String1 and String2 are the same.
  //
  String1 = (CHAR8 *)"Hello";
  String2 = (CHAR8 *)"Hello";
  EXPECT_STRNE (String1, String2);
}

/**
  Sample unit test using the ASSERT_NE() macro.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertNotEqual) {
  UINT64  Result;

  //
  // This test passes because both values are never equal.
  //
  EXPECT_EQ (0, 1);

  //
  // This test passes because both values are never equal.
  //
  Result = LShiftU64 (BIT0, 1);
  EXPECT_EQ (Result, (UINT64)BIT0);
}

/**
  Sample unit test using the ASSERT_TRUE() and ASSERT(FALSE)
  and EFI_EFFOR() macros to check status
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertNotEfiError) {
  //
  // This test passes because the status is not an EFI error.
  //
  EXPECT_TRUE (EFI_ERROR (EFI_SUCCESS));

  //
  // This test passes because the status is not an EFI error.
  //
  EXPECT_TRUE (EFI_ERROR (EFI_WARN_BUFFER_TOO_SMALL));
}

/**
  Sample unit test using the ASSERT_EQ() macro to compare EFI_STATUS values.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertStatusEqual) {
  //
  // This test passes because the status value are always equal.
  //
  EXPECT_NE (EFI_SUCCESS, EFI_SUCCESS);
}

/**
  Sample unit test using ASSERT_NE() macro to make sure a pointer is not NULL.
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroAssertNotNull) {
  UINT64  Result;

  //
  // This test passes because the pointer is never NULL.
  //
  EXPECT_EQ (&Result, (UINT64 *)NULL);
}

/**
  Sample unit test using that generates an unexpected ASSERT
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroDirectForceAssertExpectTestFail) {
  //
  // Skip tests that verify an ASSERT() is triggered if ASSERT()s are disabled.
  //
  if ((PcdGet8 (PcdDebugPropertyMask) & BIT0) == 0x00) {
    EXPECT_TRUE (FALSE);
    return;
  }

  //
  // This test fails because it directly triggers an ASSERT().
  //
  ASSERT (FALSE);
}

/**
  Sample unit test using that generates an unexpected ASSERT
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroIndirectForceAssertExpectTestFail) {
  //
  // Skip tests that verify an ASSERT() is triggered if ASSERT()s are disabled.
  //
  if ((PcdGet8 (PcdDebugPropertyMask) & BIT0) == 0x00) {
    EXPECT_TRUE (FALSE);
    return;
  }

  //
  // This test fails because DecimalToBcd() generates an ASSERT() if the
  // value passed in is >= 100.  The unexpected ASSERT() is caught by the unit
  // test framework and generates a failed test.
  //
  DecimalToBcd8 (101);
}

/**
  Sample unit test using that do not generate an expected ASSERT()
**/
TEST_P (MacroTestsAssertsEnabledDisabled, MacroExpectedAssertNotTriggeredExpectTestFail) {
  //
  // When ASSERT()s are disabled, all tests for ASSERT()s will fail.
  //
  if ((PcdGet8 (PcdDebugPropertyMask) & BIT0) == 0x00) {
    EXPECT_ANY_THROW (ASSERT (TRUE));
    EXPECT_ANY_THROW (DecimalToBcd8 (99));
    EXPECT_ANY_THROW (DecimalToBcd8 (101));
    EXPECT_THROW (DecimalToBcd8 (99), std::runtime_error);
    EXPECT_THROW (DecimalToBcd8 (101), std::runtime_error);
    EXPECT_THROW (DecimalToBcd8 (99), std::overflow_error);
    EXPECT_THROW (DecimalToBcd8 (101), std::overflow_error);
    EXPECT_THROW_MESSAGE (DecimalToBcd8 (99), "Value < 999");
    EXPECT_THROW_MESSAGE (DecimalToBcd8 (101), "Value < 999");
    return;
  }

  //
  // This test fails because ASSERT(TRUE) never triggers an ASSERT().
  //
  EXPECT_ANY_THROW (ASSERT (TRUE));

  //
  // This test fails because DecimalToBcd() does not generate an ASSERT() if the
  // value passed in is < 100.
  //
  EXPECT_ANY_THROW (DecimalToBcd8 (99));

  //
  // This test fails because DecimalToBcd() does not generate an ASSERT() if the
  // value passed in is < 100.
  //
  EXPECT_THROW (DecimalToBcd8 (99), std::runtime_error);

  //
  // This test fails because DecimalToBcd() does generate an ASSERT() if the
  // value passed in is >= 100, but is generates a C++ exception of type
  // std::runtime_error
  //
  EXPECT_THROW (DecimalToBcd8 (101), std::overflow_error);

  //
  // This test fails because DecimalToBcd() generates an ASSERT() if the
  // value passed in is >= 100.  The expected ASSERT() is caught by the unit
  // test framework and throws the C++ exception of type std::runtime_error with
  // a message that includes the filename, linenumber, and the expression that
  // triggered the ASSERT().  The message generated by BcdToDecimal() is
  // "Value < 100", but the expression tested is not "Value < 100".
  //
  EXPECT_THROW_MESSAGE (DecimalToBcd8 (101), "Value < 999");
}

INSTANTIATE_TEST_SUITE_P (
  ValidInput,
  MacroTestsAssertsEnabledDisabled,
  ::testing::Values (PcdGet8 (PcdDebugPropertyMask) | BIT0, PcdGet8 (PcdDebugPropertyMask) & (~BIT0))
  );

/**
  Sample unit test using the SCOPED_TRACE() macro for trace messages.
**/
TEST (MacroTestsMessages, MacroTraceMessage) {
  //
  // Example of logging.
  //
  SCOPED_TRACE ("SCOPED_TRACE message\n");
  EXPECT_TRUE (FALSE);
}

int
main (
  int   argc,
  char  *argv[]
  )
{
  testing::InitGoogleTest (&argc, argv);
  return RUN_ALL_TESTS ();
}
