VOID\r
EFIAPI\r
DebugVPrint (\r
- IN UINTN ErrorLevel,\r
- IN CONST CHAR8 *Format,\r
- IN VA_LIST VaListMarker\r
+ IN UINTN ErrorLevel,\r
+ IN CONST CHAR8 *Format,\r
+ IN VA_LIST VaListMarker\r
)\r
{\r
CHAR8 Buffer[MAX_DEBUG_MESSAGE_LENGTH];\r
VOID\r
EFIAPI\r
DebugBPrint (\r
- IN UINTN ErrorLevel,\r
- IN CONST CHAR8 *Format,\r
- IN BASE_LIST BaseListMarker\r
+ IN UINTN ErrorLevel,\r
+ IN CONST CHAR8 *Format,\r
+ IN BASE_LIST BaseListMarker\r
)\r
{\r
CHAR8 Buffer[MAX_DEBUG_MESSAGE_LENGTH];\r
//\r
// Generate a Breakpoint, DeadLoop, or NOP based on PCD settings\r
//\r
- if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {\r
+ if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_BREAKPOINT_ENABLED) != 0) {\r
CpuBreakpoint ();\r
- } else if ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {\r
+ } else if ((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_ASSERT_DEADLOOP_ENABLED) != 0) {\r
CpuDeadLoop ();\r
}\r
}\r
//\r
// SetMem() checks for the the ASSERT() condition on Length and returns Buffer\r
//\r
- return SetMem (Buffer, Length, PcdGet8(PcdDebugClearMemoryValue));\r
+ return SetMem (Buffer, Length, PcdGet8 (PcdDebugClearMemoryValue));\r
}\r
\r
/**\r
VOID\r
)\r
{\r
- return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);\r
+ return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_ASSERT_ENABLED) != 0);\r
}\r
\r
/**\r
VOID\r
)\r
{\r
- return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);\r
+ return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_PRINT_ENABLED) != 0);\r
}\r
\r
/**\r
VOID\r
)\r
{\r
- return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);\r
+ return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_DEBUG_CODE_ENABLED) != 0);\r
}\r
\r
/**\r
VOID\r
)\r
{\r
- return (BOOLEAN) ((PcdGet8(PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);\r
+ return (BOOLEAN)((PcdGet8 (PcdDebugPropertyMask) & DEBUG_PROPERTY_CLEAR_MEMORY_ENABLED) != 0);\r
}\r
\r
/**\r
BOOLEAN\r
EFIAPI\r
DebugPrintLevelEnabled (\r
- IN CONST UINTN ErrorLevel\r
+ IN CONST UINTN ErrorLevel\r
)\r
{\r
- return (BOOLEAN) ((ErrorLevel & PcdGet32(PcdFixedDebugPrintErrorLevel)) != 0);\r
+ return (BOOLEAN)((ErrorLevel & PcdGet32 (PcdFixedDebugPrintErrorLevel)) != 0);\r
}\r
/// aligned allocation.\r
///\r
typedef struct {\r
- UINT32 Signature;\r
- VOID *AllocatedBufffer;\r
- UINTN TotalPages;\r
- VOID *AlignedBuffer;\r
- UINTN AlignedPages;\r
+ UINT32 Signature;\r
+ VOID *AllocatedBufffer;\r
+ UINTN TotalPages;\r
+ VOID *AlignedBuffer;\r
+ UINTN AlignedPages;\r
} PAGE_HEAD;\r
\r
/**\r
if (Alignment < SIZE_4KB) {\r
Alignment = SIZE_4KB;\r
}\r
- AlignmentMask = Alignment - 1;\r
+\r
+ AlignmentMask = Alignment - 1;\r
\r
//\r
// We need reserve Alignment pages for PAGE_HEAD, as meta data.\r
//\r
- PageHead.Signature = PAGE_HEAD_PRIVATE_SIGNATURE;\r
- PageHead.TotalPages = Pages + EFI_SIZE_TO_PAGES (Alignment) * 2;\r
- PageHead.AlignedPages = Pages;\r
+ PageHead.Signature = PAGE_HEAD_PRIVATE_SIGNATURE;\r
+ PageHead.TotalPages = Pages + EFI_SIZE_TO_PAGES (Alignment) * 2;\r
+ PageHead.AlignedPages = Pages;\r
PageHead.AllocatedBufffer = malloc (EFI_PAGES_TO_SIZE (PageHead.TotalPages));\r
if (PageHead.AllocatedBufffer == NULL) {\r
return NULL;\r
}\r
- PageHead.AlignedBuffer = (VOID *)(((UINTN) PageHead.AllocatedBufffer + AlignmentMask) & ~AlignmentMask);\r
- if ((UINTN)PageHead.AlignedBuffer - (UINTN)PageHead.AllocatedBufffer < sizeof(PAGE_HEAD)) {\r
+\r
+ PageHead.AlignedBuffer = (VOID *)(((UINTN)PageHead.AllocatedBufffer + AlignmentMask) & ~AlignmentMask);\r
+ if ((UINTN)PageHead.AlignedBuffer - (UINTN)PageHead.AllocatedBufffer < sizeof (PAGE_HEAD)) {\r
PageHead.AlignedBuffer = (VOID *)((UINTN)PageHead.AlignedBuffer + Alignment);\r
}\r
\r
- PageHeadPtr = (VOID *)((UINTN)PageHead.AlignedBuffer - sizeof(PAGE_HEAD));\r
- memcpy (PageHeadPtr, &PageHead, sizeof(PAGE_HEAD));\r
+ PageHeadPtr = (VOID *)((UINTN)PageHead.AlignedBuffer - sizeof (PAGE_HEAD));\r
+ memcpy (PageHeadPtr, &PageHead, sizeof (PAGE_HEAD));\r
\r
return PageHead.AlignedBuffer;\r
}\r
//\r
// NOTE: Partial free is not supported. Just keep it.\r
//\r
- PageHeadPtr = (VOID *)((UINTN)Buffer - sizeof(PAGE_HEAD));\r
+ PageHeadPtr = (VOID *)((UINTN)Buffer - sizeof (PAGE_HEAD));\r
if (PageHeadPtr->Signature != PAGE_HEAD_PRIVATE_SIGNATURE) {\r
return;\r
}\r
+\r
if (PageHeadPtr->AlignedPages != Pages) {\r
return;\r
}\r
if (Buffer == NULL) {\r
return NULL;\r
}\r
+\r
memset (Buffer, 0, AllocationSize);\r
return Buffer;\r
}\r
if (Memory == NULL) {\r
return NULL;\r
}\r
+\r
memcpy (Memory, Buffer, AllocationSize);\r
return Memory;\r
}\r
VOID *NewBuffer;\r
\r
NewBuffer = malloc (NewSize);\r
- if (NewBuffer != NULL && OldBuffer != NULL) {\r
+ if ((NewBuffer != NULL) && (OldBuffer != NULL)) {\r
memcpy (NewBuffer, OldBuffer, MIN (OldSize, NewSize));\r
}\r
+\r
if (OldBuffer != NULL) {\r
- FreePool(OldBuffer);\r
+ FreePool (OldBuffer);\r
}\r
+\r
return NewBuffer;\r
}\r
\r
**/\r
EFI_STATUS\r
EFIAPI\r
-SetBootNextDevice(\r
+SetBootNextDevice (\r
VOID\r
)\r
{\r
EFI_STATUS\r
EFIAPI\r
SetBootNextDevice (\r
- VOID\r
+ VOID\r
)\r
{\r
EFI_STATUS Status;\r
Dp = NULL;\r
NewOptionValid = FALSE;\r
\r
- UsbDp.Header.Length[0] = (UINT8)(sizeof(USB_CLASS_DEVICE_PATH) & 0xff);\r
- UsbDp.Header.Length[1] = (UINT8)(sizeof(USB_CLASS_DEVICE_PATH) >> 8);\r
+ UsbDp.Header.Length[0] = (UINT8)(sizeof (USB_CLASS_DEVICE_PATH) & 0xff);\r
+ UsbDp.Header.Length[1] = (UINT8)(sizeof (USB_CLASS_DEVICE_PATH) >> 8);\r
UsbDp.Header.Type = MESSAGING_DEVICE_PATH;\r
UsbDp.Header.SubType = MSG_USB_CLASS_DP;\r
UsbDp.VendorId = 0xFFFF;\r
goto CLEANUP;\r
}\r
\r
- //@MRT --- Is this memory leak because we lose the old Dp memory\r
+ // @MRT --- Is this memory leak because we lose the old Dp memory\r
Dp = AppendDevicePathNode (\r
DpEnd,\r
(EFI_DEVICE_PATH_PROTOCOL *)&UsbDp\r
);\r
if (Dp == NULL) {\r
- DEBUG((DEBUG_ERROR, "%a: Unable to create device path. Dp is NULL.\n", __FUNCTION__));\r
+ DEBUG ((DEBUG_ERROR, "%a: Unable to create device path. Dp is NULL.\n", __FUNCTION__));\r
Status = EFI_OUT_OF_RESOURCES;\r
goto CLEANUP;\r
}\r
\r
Status = EfiBootManagerInitializeLoadOption (\r
&NewOption,\r
- (UINTN) BootNextValue,\r
+ (UINTN)BootNextValue,\r
LoadOptionTypeBoot,\r
Attributes,\r
L"Generic USB Class Device",\r
L"BootNext",\r
&gEfiGlobalVariableGuid,\r
(EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS | EFI_VARIABLE_NON_VOLATILE),\r
- sizeof(BootNextValue),\r
+ sizeof (BootNextValue),\r
&(BootNextValue)\r
);\r
\r
- DEBUG((DEBUG_VERBOSE, "%a - Set BootNext Status (%r)\n", __FUNCTION__, Status));\r
+ DEBUG ((DEBUG_VERBOSE, "%a - Set BootNext Status (%r)\n", __FUNCTION__, Status));\r
\r
CLEANUP:\r
if (Dp != NULL) {\r
FreePool (Dp);\r
}\r
+\r
if (DpEnd != NULL) {\r
FreePool (DpEnd);\r
}\r
+\r
if (NewOptionValid) {\r
EfiBootManagerFreeLoadOption (&NewOption);\r
}\r
+\r
return Status;\r
}\r
UT_LOG_INFO ("Detected expected ASSERT: %a(%d): %a\n", FileName, LineNumber, Description);\r
LongJump (gUnitTestExpectAssertFailureJumpBuffer, 1);\r
} else {\r
- AsciiStrCpyS (Message, sizeof(Message), "Detected unexpected ASSERT(");\r
- AsciiStrCatS (Message, sizeof(Message), Description);\r
- AsciiStrCatS (Message, sizeof(Message), ")");\r
+ AsciiStrCpyS (Message, sizeof (Message), "Detected unexpected ASSERT(");\r
+ AsciiStrCatS (Message, sizeof (Message), Description);\r
+ AsciiStrCatS (Message, sizeof (Message), ")");\r
UnitTestAssertTrue (FALSE, "", LineNumber, FileName, Message);\r
}\r
}\r
//\r
// Make sure that you're cooking with gas.\r
//\r
- if (UnitTest == NULL || FailureMessage == NULL) {\r
+ if ((UnitTest == NULL) || (FailureMessage == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
Description\r
);\r
}\r
+\r
return Expression;\r
}\r
\r
Description\r
);\r
}\r
+\r
return !Expression;\r
}\r
\r
Status\r
);\r
}\r
- return !EFI_ERROR( Status );\r
+\r
+ return !EFI_ERROR (Status);\r
}\r
\r
/**\r
ValueB\r
);\r
}\r
+\r
return (ValueA == ValueB);\r
}\r
\r
IN CONST CHAR8 *DescriptionB\r
)\r
{\r
- if (CompareMem(BufferA, BufferB, Length) != 0) {\r
+ if (CompareMem (BufferA, BufferB, Length) != 0) {\r
UT_LOG_ERROR (\r
"[ASSERT FAIL] %a:%d: Value %a != %a for length %d bytes!\n",\r
FileName,\r
);\r
return FALSE;\r
}\r
+\r
return TRUE;\r
}\r
\r
ValueB\r
);\r
}\r
+\r
return (ValueA != ValueB);\r
}\r
\r
Expected\r
);\r
}\r
+\r
return (Status == Expected);\r
}\r
\r
PointerName\r
);\r
}\r
+\r
return (Pointer != NULL);\r
}\r
\r
if (ResultStatus != NULL) {\r
*ResultStatus = UnitTestStatus;\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_PASSED) {\r
UT_LOG_INFO (\r
"[ASSERT PASS] %a:%d: UT_EXPECT_ASSERT_FAILURE(%a) detected expected assert\n",\r
FunctionCall\r
);\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_SKIPPED) {\r
UT_LOG_WARNING (\r
"[ASSERT WARN] %a:%d: UT_EXPECT_ASSERT_FAILURE(%a) disabled\n",\r
FunctionCall\r
);\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_ERROR_TEST_FAILED) {\r
UT_LOG_ERROR (\r
"[ASSERT FAIL] %a:%d: Function call (%a) did not ASSERT()!\n",\r
FunctionCall\r
);\r
}\r
+\r
return (UnitTestStatus != UNIT_TEST_ERROR_TEST_FAILED);\r
}\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_TRUE(%s:%x)", Description, Expression);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_TRUE(%s:%x)", Description, Expression);\r
_assert_true (Expression, TempStr, FileName, (INT32)LineNumber);\r
\r
return Expression;\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_FALSE(%s:%x)", Description, Expression);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_FALSE(%s:%x)", Description, Expression);\r
_assert_true (!Expression, TempStr, FileName, (INT32)LineNumber);\r
\r
return !Expression;\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_NOT_EFI_ERROR(%s:%p)", Description, (void *)Status);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_NOT_EFI_ERROR(%s:%p)", Description, (void *)Status);\r
_assert_true (!EFI_ERROR (Status), TempStr, FileName, (INT32)LineNumber);\r
\r
return !EFI_ERROR (Status);\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_EQUAL(%s:%llx, %s:%llx)", DescriptionA, ValueA, DescriptionB, ValueB);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_EQUAL(%s:%llx, %s:%llx)", DescriptionA, ValueA, DescriptionB, ValueB);\r
_assert_true ((ValueA == ValueB), TempStr, FileName, (INT32)LineNumber);\r
\r
return (ValueA == ValueB);\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
BOOLEAN Result;\r
\r
- Result = (CompareMem(BufferA, BufferB, Length) == 0);\r
+ Result = (CompareMem (BufferA, BufferB, Length) == 0);\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_MEM_EQUAL(%s:%p, %s:%p)", DescriptionA, BufferA, DescriptionB, BufferB);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_MEM_EQUAL(%s:%p, %s:%p)", DescriptionA, BufferA, DescriptionB, BufferB);\r
_assert_true (Result, TempStr, FileName, (INT32)LineNumber);\r
\r
return Result;\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_NOT_EQUAL(%s:%llx, %s:%llx)", DescriptionA, ValueA, DescriptionB, ValueB);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_NOT_EQUAL(%s:%llx, %s:%llx)", DescriptionA, ValueA, DescriptionB, ValueB);\r
_assert_true ((ValueA != ValueB), TempStr, FileName, (INT32)LineNumber);\r
\r
return (ValueA != ValueB);\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_STATUS_EQUAL(%s:%p)", Description, (VOID *)Status);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_STATUS_EQUAL(%s:%p)", Description, (VOID *)Status);\r
_assert_true ((Status == Expected), TempStr, FileName, (INT32)LineNumber);\r
\r
return (Status == Expected);\r
{\r
CHAR8 TempStr[MAX_STRING_SIZE];\r
\r
- snprintf (TempStr, sizeof(TempStr), "UT_ASSERT_NOT_NULL(%s:%p)", PointerName, Pointer);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_ASSERT_NOT_NULL(%s:%p)", PointerName, Pointer);\r
_assert_true ((Pointer != NULL), TempStr, FileName, (INT32)LineNumber);\r
\r
return (Pointer != NULL);\r
if (ResultStatus != NULL) {\r
*ResultStatus = UnitTestStatus;\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_PASSED) {\r
UT_LOG_INFO (\r
"[ASSERT PASS] %a:%d: UT_EXPECT_ASSERT_FAILURE(%a) detected expected assert\n",\r
FunctionCall\r
);\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_SKIPPED) {\r
UT_LOG_WARNING (\r
"[ASSERT WARN] %a:%d: UT_EXPECT_ASSERT_FAILURE(%a) disabled\n",\r
FunctionCall\r
);\r
}\r
+\r
if (UnitTestStatus == UNIT_TEST_ERROR_TEST_FAILED) {\r
- snprintf (TempStr, sizeof(TempStr), "UT_EXPECT_ASSERT_FAILURE(%s) did not trigger ASSERT()", FunctionCall);\r
+ snprintf (TempStr, sizeof (TempStr), "UT_EXPECT_ASSERT_FAILURE(%s) did not trigger ASSERT()", FunctionCall);\r
_assert_true (FALSE, TempStr, FileName, (INT32)LineNumber);\r
}\r
+\r
return (UnitTestStatus != UNIT_TEST_ERROR_TEST_FAILED);\r
}\r
#define UNIT_TEST_MAX_LOG_BUFFER SIZE_16KB\r
\r
struct _UNIT_TEST_LOG_PREFIX_STRING {\r
- UNIT_TEST_STATUS LogLevel;\r
- CHAR8 *String;\r
+ UNIT_TEST_STATUS LogLevel;\r
+ CHAR8 *String;\r
};\r
\r
struct _UNIT_TEST_LOG_PREFIX_STRING mLogPrefixStrings[] = {\r
//\r
\r
STATIC\r
-CONST CHAR8*\r
+CONST CHAR8 *\r
GetStringForStatusLogPrefix (\r
IN UINTN LogLevel\r
)\r
break;\r
}\r
}\r
+\r
return Result;\r
}\r
\r
//\r
// Make sure that you're cooking with gas.\r
//\r
- if (UnitTest == NULL || String == NULL) {\r
+ if ((UnitTest == NULL) || (String == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
String,\r
UNIT_TEST_MAX_SINGLE_LOG_STRING_LENGTH\r
);\r
- if(EFI_ERROR (Status)) {\r
+ if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_ERROR, "Failed to add unit test log string. Status = %r\n", Status));\r
return Status;\r
}\r
}\r
\r
//\r
- //check again to make sure allocate worked\r
+ // check again to make sure allocate worked\r
//\r
- if(Test->Log == NULL) {\r
+ if (Test->Log == NULL) {\r
DEBUG ((DEBUG_ERROR, "Failed to allocate memory for the log\n"));\r
return;\r
}\r
\r
- if((Buffer != NULL) && (BufferSize > 0) && (BufferSize <= UNIT_TEST_MAX_LOG_BUFFER)) {\r
+ if ((Buffer != NULL) && (BufferSize > 0) && (BufferSize <= UNIT_TEST_MAX_LOG_BUFFER)) {\r
CopyMem (Test->Log, Buffer, BufferSize);\r
}\r
}\r
// Iterate all tests within the suite\r
//\r
for (TestEntry = (UNIT_TEST_LIST_ENTRY *)GetFirstNode (&(Suite->TestCaseList));\r
- (LIST_ENTRY*)TestEntry != &(Suite->TestCaseList);\r
- TestEntry = (UNIT_TEST_LIST_ENTRY *)GetNextNode (&(Suite->TestCaseList), (LIST_ENTRY *)TestEntry)) {\r
+ (LIST_ENTRY *)TestEntry != &(Suite->TestCaseList);\r
+ TestEntry = (UNIT_TEST_LIST_ENTRY *)GetNextNode (&(Suite->TestCaseList), (LIST_ENTRY *)TestEntry))\r
+ {\r
Test = &TestEntry->UT;\r
ParentFramework->CurrentTest = Test;\r
\r
// First, check to see whether the test has already been run.\r
// NOTE: This would generally only be the case if a saved state was detected and loaded.\r
//\r
- if (Test->Result != UNIT_TEST_PENDING && Test->Result != UNIT_TEST_RUNNING) {\r
+ if ((Test->Result != UNIT_TEST_PENDING) && (Test->Result != UNIT_TEST_RUNNING)) {\r
DEBUG ((DEBUG_VERBOSE, "Test was run on a previous pass. Skipping.\n"));\r
ParentFramework->CurrentTest = NULL;\r
continue;\r
\r
//\r
// Next, if we're still running, make sure that our test prerequisites are in place.\r
- if (Test->Result == UNIT_TEST_PENDING && Test->Prerequisite != NULL) {\r
+ if ((Test->Result == UNIT_TEST_PENDING) && (Test->Prerequisite != NULL)) {\r
DEBUG ((DEBUG_VERBOSE, "PREREQ\n"));\r
if (SetJump (&gUnitTestJumpBuffer) == 0) {\r
if (Test->Prerequisite (Test->Context) != UNIT_TEST_PASSED) {\r
DEBUG ((DEBUG_ERROR, "Prerequisite Not Met\n"));\r
- Test->Result = UNIT_TEST_ERROR_PREREQUISITE_NOT_MET;\r
- ParentFramework->CurrentTest = NULL;\r
+ Test->Result = UNIT_TEST_ERROR_PREREQUISITE_NOT_MET;\r
+ ParentFramework->CurrentTest = NULL;\r
continue;\r
}\r
} else {\r
DEBUG ((DEBUG_ERROR, "Prerequisite Not Met\n"));\r
- Test->Result = UNIT_TEST_ERROR_PREREQUISITE_NOT_MET;\r
- ParentFramework->CurrentTest = NULL;\r
+ Test->Result = UNIT_TEST_ERROR_PREREQUISITE_NOT_MET;\r
+ ParentFramework->CurrentTest = NULL;\r
continue;\r
}\r
}\r
// Iterate all suites\r
//\r
for (Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetFirstNode (&Framework->TestSuiteList);\r
- (LIST_ENTRY *)Suite != &Framework->TestSuiteList;\r
- Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetNextNode (&Framework->TestSuiteList, (LIST_ENTRY *)Suite)) {\r
+ (LIST_ENTRY *)Suite != &Framework->TestSuiteList;\r
+ Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetNextNode (&Framework->TestSuiteList, (LIST_ENTRY *)Suite))\r
+ {\r
Status = RunTestSuite (&(Suite->UTS));\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_ERROR, "Test Suite Failed with Error. %r\n", Status));\r
\r
void\r
CmockaUnitTestFunctionRunner (\r
- void **state\r
+ void **state\r
)\r
{\r
UNIT_TEST *UnitTest;\r
if (UnitTest->RunTest == NULL) {\r
UnitTest->Result = UNIT_TEST_SKIPPED;\r
} else {\r
- UnitTest->Result = UNIT_TEST_RUNNING;\r
+ UnitTest->Result = UNIT_TEST_RUNNING;\r
Framework->CurrentTest = UnitTest;\r
- UnitTest->Result = UnitTest->RunTest (UnitTest->Context);\r
+ UnitTest->Result = UnitTest->RunTest (UnitTest->Context);\r
Framework->CurrentTest = NULL;\r
}\r
}\r
\r
int\r
CmockaUnitTestSetupFunctionRunner (\r
- void **state\r
+ void **state\r
)\r
{\r
UNIT_TEST *UnitTest;\r
}\r
\r
Framework->CurrentTest = UnitTest;\r
- Result = UnitTest->Prerequisite (UnitTest->Context);\r
+ Result = UnitTest->Prerequisite (UnitTest->Context);\r
Framework->CurrentTest = NULL;\r
\r
//\r
\r
int\r
CmockaUnitTestTeardownFunctionRunner (\r
- void **state\r
+ void **state\r
)\r
{\r
UNIT_TEST *UnitTest;\r
// stdout and stderr in their xml format\r
//\r
if (UnitTest->Log != NULL) {\r
- print_message("UnitTest: %s - %s\n", UnitTest->Name, UnitTest->Description);\r
- print_message("Log Output Start\n");\r
- print_message("%s", UnitTest->Log);\r
- print_message("Log Output End\n");\r
+ print_message ("UnitTest: %s - %s\n", UnitTest->Name, UnitTest->Description);\r
+ print_message ("Log Output Start\n");\r
+ print_message ("%s", UnitTest->Log);\r
+ print_message ("Log Output End\n");\r
}\r
\r
//\r
\r
int\r
CmockaUnitTestSuiteSetupFunctionRunner (\r
- void **state\r
+ void **state\r
)\r
{\r
if (mActiveUnitTestSuite == NULL) {\r
return -1;\r
}\r
+\r
if (mActiveUnitTestSuite->Setup == NULL) {\r
return 0;\r
}\r
\r
int\r
CmockaUnitTestSuiteTeardownFunctionRunner (\r
- void **state\r
+ void **state\r
)\r
{\r
if (mActiveUnitTestSuite == NULL) {\r
return -1;\r
}\r
+\r
if (mActiveUnitTestSuite->Teardown == NULL) {\r
return 0;\r
}\r
struct CMUnitTest *Tests;\r
UINTN Index;\r
\r
- TestEntry = NULL;\r
+ TestEntry = NULL;\r
\r
if (Suite == NULL) {\r
return EFI_INVALID_PARAMETER;\r
Index = 0;\r
for (TestEntry = (UNIT_TEST_LIST_ENTRY *)GetFirstNode (&(Suite->TestCaseList));\r
(LIST_ENTRY *)TestEntry != &(Suite->TestCaseList);\r
- TestEntry = (UNIT_TEST_LIST_ENTRY *)GetNextNode (&(Suite->TestCaseList), (LIST_ENTRY *)TestEntry)) {\r
+ TestEntry = (UNIT_TEST_LIST_ENTRY *)GetNextNode (&(Suite->TestCaseList), (LIST_ENTRY *)TestEntry))\r
+ {\r
UnitTest = &TestEntry->UT;\r
Tests[Index].name = UnitTest->Description;\r
Tests[Index].test_func = CmockaUnitTestFunctionRunner;\r
Tests[Index].initial_state = UnitTest;\r
Index++;\r
}\r
+\r
ASSERT (Index == Suite->NumTests);\r
\r
//\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
- DEBUG((DEBUG_VERBOSE, "---------------------------------------------------------\n"));\r
- DEBUG((DEBUG_VERBOSE, "------------ RUNNING ALL TEST SUITES --------------\n"));\r
- DEBUG((DEBUG_VERBOSE, "---------------------------------------------------------\n"));\r
+ DEBUG ((DEBUG_VERBOSE, "---------------------------------------------------------\n"));\r
+ DEBUG ((DEBUG_VERBOSE, "------------ RUNNING ALL TEST SUITES --------------\n"));\r
+ DEBUG ((DEBUG_VERBOSE, "---------------------------------------------------------\n"));\r
mFrameworkHandle = FrameworkHandle;\r
\r
//\r
// Iterate all suites\r
//\r
for (Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetFirstNode (&Framework->TestSuiteList);\r
- (LIST_ENTRY *)Suite != &Framework->TestSuiteList;\r
- Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetNextNode (&Framework->TestSuiteList, (LIST_ENTRY *)Suite)) {\r
+ (LIST_ENTRY *)Suite != &Framework->TestSuiteList;\r
+ Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetNextNode (&Framework->TestSuiteList, (LIST_ENTRY *)Suite))\r
+ {\r
Status = RunTestSuite (&(Suite->UTS));\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_ERROR, "Test Suite Failed with Error. %r\n", Status));\r
}\r
\r
STATIC\r
-CHAR8*\r
+CHAR8 *\r
AllocateAndCopyString (\r
IN CHAR8 *StringToCopy\r
)\r
CHAR8 *NewString;\r
UINTN NewStringLength;\r
\r
- NewString = NULL;\r
+ NewString = NULL;\r
NewStringLength = AsciiStrnLenS (StringToCopy, UNIT_TEST_MAX_STRING_LENGTH) + 1;\r
- NewString = AllocatePool (NewStringLength * sizeof( CHAR8 ));\r
+ NewString = AllocatePool (NewStringLength * sizeof (CHAR8));\r
if (NewString != NULL) {\r
AsciiStrCpyS (NewString, NewStringLength, StringToCopy);\r
}\r
+\r
return NewString;\r
}\r
\r
UINT32 NewFingerprint;\r
\r
// For this one we'll just use the title and version as the unique fingerprint.\r
- NewFingerprint = CalculateCrc32( Framework->Title, (AsciiStrLen( Framework->Title ) * sizeof( CHAR8 )) );\r
- NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32( Framework->VersionString, (AsciiStrLen( Framework->VersionString ) * sizeof( CHAR8 )) );\r
+ NewFingerprint = CalculateCrc32 (Framework->Title, (AsciiStrLen (Framework->Title) * sizeof (CHAR8)));\r
+ NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32 (Framework->VersionString, (AsciiStrLen (Framework->VersionString) * sizeof (CHAR8)));\r
\r
- CopyMem( Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE );\r
+ CopyMem (Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE);\r
return;\r
}\r
\r
UINT32 NewFingerprint;\r
\r
// For this one, we'll use the fingerprint from the framework, and the title of the suite.\r
- NewFingerprint = CalculateCrc32( &Framework->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE );\r
- NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32( Suite->Title, (AsciiStrLen( Suite->Title ) * sizeof( CHAR8 )) );\r
- NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32( Suite->Name, (AsciiStrLen(Suite->Name) * sizeof(CHAR8)) );\r
+ NewFingerprint = CalculateCrc32 (&Framework->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE);\r
+ NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32 (Suite->Title, (AsciiStrLen (Suite->Title) * sizeof (CHAR8)));\r
+ NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32 (Suite->Name, (AsciiStrLen (Suite->Name) * sizeof (CHAR8)));\r
\r
- CopyMem( Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE );\r
+ CopyMem (Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE);\r
return;\r
}\r
\r
UINT32 NewFingerprint;\r
\r
// For this one, we'll use the fingerprint from the suite, and the description and classname of the test.\r
- NewFingerprint = CalculateCrc32( &Suite->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE );\r
- NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32( Test->Description, (AsciiStrLen( Test->Description ) * sizeof( CHAR8 )) );\r
- NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32( Test->Name, (AsciiStrLen(Test->Name) * sizeof(CHAR8)) );\r
+ NewFingerprint = CalculateCrc32 (&Suite->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE);\r
+ NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32 (Test->Description, (AsciiStrLen (Test->Description) * sizeof (CHAR8)));\r
+ NewFingerprint = (NewFingerprint >> 8) ^ CalculateCrc32 (Test->Name, (AsciiStrLen (Test->Name) * sizeof (CHAR8)));\r
\r
- CopyMem( Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE );\r
+ CopyMem (Fingerprint, &NewFingerprint, UNIT_TEST_FINGERPRINT_SIZE);\r
return;\r
}\r
\r
IN UINT8 *FingerprintB\r
)\r
{\r
- return (CompareMem( FingerprintA, FingerprintB, UNIT_TEST_FINGERPRINT_SIZE ) == 0);\r
+ return (CompareMem (FingerprintA, FingerprintB, UNIT_TEST_FINGERPRINT_SIZE) == 0);\r
}\r
\r
/**\r
//\r
// First, check all pointers and make sure nothing's broked.\r
//\r
- if (FrameworkHandle == NULL || Title == NULL ||\r
- ShortTitle == NULL || VersionString == NULL) {\r
+ if ((FrameworkHandle == NULL) || (Title == NULL) ||\r
+ (ShortTitle == NULL) || (VersionString == NULL))\r
+ {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
NewFramework->Log = NULL;\r
NewFramework->CurrentTest = NULL;\r
NewFramework->SavedState = NULL;\r
- if (NewFramework->Title == NULL ||\r
- NewFramework->ShortTitle == NULL ||\r
- NewFramework->VersionString == NULL) {\r
+ if ((NewFramework->Title == NULL) ||\r
+ (NewFramework->ShortTitle == NULL) ||\r
+ (NewFramework->VersionString == NULL))\r
+ {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Exit;\r
}\r
+\r
InitializeListHead (&(NewFramework->TestSuiteList));\r
\r
//\r
// If there is a persisted context, load it now.\r
//\r
if (DoesCacheExist (NewFrameworkHandle)) {\r
- Status = LoadUnitTestCache (NewFrameworkHandle, (UNIT_TEST_SAVE_HEADER**)(&NewFramework->SavedState));\r
+ Status = LoadUnitTestCache (NewFrameworkHandle, (UNIT_TEST_SAVE_HEADER **)(&NewFramework->SavedState));\r
if (EFI_ERROR (Status)) {\r
//\r
// Don't actually report it as an error, but emit a warning.\r
//\r
- DEBUG (( DEBUG_ERROR, "%a - Cache was detected, but failed to load.\n", __FUNCTION__ ));\r
+ DEBUG ((DEBUG_ERROR, "%a - Cache was detected, but failed to load.\n", __FUNCTION__));\r
Status = EFI_SUCCESS;\r
}\r
}\r
UNIT_TEST_SUITE_LIST_ENTRY *NewSuiteEntry;\r
UNIT_TEST_FRAMEWORK *Framework;\r
\r
- Status = EFI_SUCCESS;\r
+ Status = EFI_SUCCESS;\r
Framework = (UNIT_TEST_FRAMEWORK *)FrameworkHandle;\r
\r
//\r
//\r
// Copy the fields we think we need.\r
//\r
- NewSuiteEntry->UTS.NumTests = 0;\r
- NewSuiteEntry->UTS.Title = AllocateAndCopyString (Title);\r
- NewSuiteEntry->UTS.Name = AllocateAndCopyString (Name);\r
- NewSuiteEntry->UTS.Setup = Setup;\r
- NewSuiteEntry->UTS.Teardown = Teardown;\r
- NewSuiteEntry->UTS.ParentFramework = FrameworkHandle;\r
+ NewSuiteEntry->UTS.NumTests = 0;\r
+ NewSuiteEntry->UTS.Title = AllocateAndCopyString (Title);\r
+ NewSuiteEntry->UTS.Name = AllocateAndCopyString (Name);\r
+ NewSuiteEntry->UTS.Setup = Setup;\r
+ NewSuiteEntry->UTS.Teardown = Teardown;\r
+ NewSuiteEntry->UTS.ParentFramework = FrameworkHandle;\r
InitializeListHead (&(NewSuiteEntry->Entry)); // List entry for sibling suites.\r
InitializeListHead (&(NewSuiteEntry->UTS.TestCaseList)); // List entry for child tests.\r
if (NewSuiteEntry->UTS.Title == NULL) {\r
//\r
// Create the suite fingerprint.\r
//\r
- SetSuiteFingerprint( &NewSuiteEntry->UTS.Fingerprint[0], Framework, &NewSuiteEntry->UTS );\r
+ SetSuiteFingerprint (&NewSuiteEntry->UTS.Fingerprint[0], Framework, &NewSuiteEntry->UTS);\r
\r
Exit:\r
//\r
// If everything is going well, add the new suite to the tail list for the framework.\r
//\r
- if (!EFI_ERROR( Status )) {\r
+ if (!EFI_ERROR (Status)) {\r
InsertTailList (&(Framework->TestSuiteList), (LIST_ENTRY *)NewSuiteEntry);\r
*SuiteHandle = (UNIT_TEST_SUITE_HANDLE)(&NewSuiteEntry->UTS);\r
} else {\r
UNIT_TEST_FRAMEWORK *ParentFramework;\r
UNIT_TEST_SUITE *Suite;\r
\r
- Status = EFI_SUCCESS;\r
- Suite = (UNIT_TEST_SUITE *)SuiteHandle;\r
+ Status = EFI_SUCCESS;\r
+ Suite = (UNIT_TEST_SUITE *)SuiteHandle;\r
\r
//\r
// First, let's check to make sure that our parameters look good.\r
ParentFramework = (UNIT_TEST_FRAMEWORK *)Suite->ParentFramework;\r
//\r
// Create the new entry.\r
- NewTestEntry = AllocateZeroPool (sizeof( UNIT_TEST_LIST_ENTRY ));\r
+ NewTestEntry = AllocateZeroPool (sizeof (UNIT_TEST_LIST_ENTRY));\r
if (NewTestEntry == NULL) {\r
return EFI_OUT_OF_RESOURCES;\r
}\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Exit;\r
}\r
+\r
if (NewTestEntry->UT.Name == NULL) {\r
Status = EFI_OUT_OF_RESOURCES;\r
goto Exit;\r
// If everything is going well, add the new suite to the tail list for the framework.\r
//\r
if (!EFI_ERROR (Status)) {\r
- InsertTailList (&(Suite->TestCaseList), (LIST_ENTRY*)NewTestEntry);\r
+ InsertTailList (&(Suite->TestCaseList), (LIST_ENTRY *)NewTestEntry);\r
Suite->NumTests++;\r
} else {\r
//\r
//\r
// First, evaluate the inputs.\r
//\r
- if (Test == NULL || SavedState == NULL) {\r
+ if ((Test == NULL) || (SavedState == NULL)) {\r
return;\r
}\r
+\r
if (SavedState->TestCount == 0) {\r
return;\r
}\r
// at the beginning of the context structure.\r
//\r
SavedContext = (UNIT_TEST_SAVE_CONTEXT *)FloatingPointer;\r
- if ((SavedContext->Size - sizeof (UNIT_TEST_SAVE_CONTEXT)) > 0 &&\r
- CompareFingerprints (&Test->Fingerprint[0], &SavedContext->Fingerprint[0])) {\r
+ if (((SavedContext->Size - sizeof (UNIT_TEST_SAVE_CONTEXT)) > 0) &&\r
+ CompareFingerprints (&Test->Fingerprint[0], &SavedContext->Fingerprint[0]))\r
+ {\r
//\r
// Override the test context with the saved context.\r
//\r
- Test->Context = (VOID*)SavedContext->Data;\r
+ Test->Context = (VOID *)SavedContext->Data;\r
}\r
}\r
}\r
\r
STATIC\r
-UNIT_TEST_SAVE_HEADER*\r
+UNIT_TEST_SAVE_HEADER *\r
SerializeState (\r
IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle,\r
IN UNIT_TEST_CONTEXT ContextToSave OPTIONAL,\r
//\r
// First, let's not make assumptions about the parameters.\r
//\r
- if (Framework == NULL ||\r
- (ContextToSave != NULL && ContextToSaveSize == 0) ||\r
- ContextToSaveSize > MAX_UINT32) {\r
+ if ((Framework == NULL) ||\r
+ ((ContextToSave != NULL) && (ContextToSaveSize == 0)) ||\r
+ (ContextToSaveSize > MAX_UINT32))\r
+ {\r
return NULL;\r
}\r
\r
//\r
// Account for the size of a test structure.\r
//\r
- TotalSize += sizeof( UNIT_TEST_SAVE_TEST );\r
+ TotalSize += sizeof (UNIT_TEST_SAVE_TEST);\r
//\r
// If there's a log, make sure to account for the log size.\r
//\r
- if (UnitTest->Log != NULL) {\r
+ if (UnitTest->Log != NULL) {\r
//\r
// The +1 is for the NULL character. Can't forget the NULL character.\r
//\r
ASSERT (LogSize < MAX_UINT32);\r
TotalSize += (UINT32)LogSize;\r
}\r
+\r
//\r
// Increment the test count.\r
//\r
TestCount++;\r
}\r
}\r
+\r
//\r
// If there are no tests, we're done here.\r
//\r
if (TestCount == 0) {\r
return NULL;\r
}\r
+\r
//\r
// Add room for the context, if there is one.\r
//\r
//\r
// Alright, let's start setting up some data.\r
//\r
- Header->Version = UNIT_TEST_PERSISTENCE_LIB_VERSION;\r
- Header->SaveStateSize = TotalSize;\r
+ Header->Version = UNIT_TEST_PERSISTENCE_LIB_VERSION;\r
+ Header->SaveStateSize = TotalSize;\r
CopyMem (&Header->Fingerprint[0], &Framework->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE);\r
CopyMem (&Header->StartTime, &Framework->StartTime, sizeof (EFI_TIME));\r
Header->TestCount = TestCount;\r
// Start adding all of the test cases.\r
// Set the floating pointer to the start of the current test save buffer.\r
//\r
- FloatingPointer = (UINT8*)Header + sizeof( UNIT_TEST_SAVE_HEADER );\r
+ FloatingPointer = (UINT8 *)Header + sizeof (UNIT_TEST_SAVE_HEADER);\r
//\r
// Iterate all suites.\r
//\r
//\r
TestListHead = &((UNIT_TEST_SUITE_LIST_ENTRY *)Suite)->UTS.TestCaseList;\r
for (Test = GetFirstNode (TestListHead); Test != TestListHead; Test = GetNextNode (TestListHead, Test)) {\r
- TestSaveData = (UNIT_TEST_SAVE_TEST *)FloatingPointer;\r
- UnitTest = &((UNIT_TEST_LIST_ENTRY *)Test)->UT;\r
+ TestSaveData = (UNIT_TEST_SAVE_TEST *)FloatingPointer;\r
+ UnitTest = &((UNIT_TEST_LIST_ENTRY *)Test)->UT;\r
\r
//\r
// Save the fingerprint.\r
//\r
// Save the result.\r
//\r
- TestSaveData->Result = UnitTest->Result;\r
+ TestSaveData->Result = UnitTest->Result;\r
TestSaveData->FailureType = UnitTest->FailureType;\r
AsciiStrnCpyS (&TestSaveData->FailureMessage[0], UNIT_TEST_TESTFAILUREMSG_LENGTH, &UnitTest->FailureMessage[0], UNIT_TEST_TESTFAILUREMSG_LENGTH);\r
\r
-\r
//\r
// If there is a log, save the log.\r
//\r
//\r
// If there is a context to save, let's do that now.\r
//\r
- if (ContextToSave != NULL && Framework->CurrentTest != NULL) {\r
- TestSaveContext = (UNIT_TEST_SAVE_CONTEXT*)FloatingPointer;\r
- TestSaveContext->Size = (UINT32)ContextToSaveSize + sizeof (UNIT_TEST_SAVE_CONTEXT);\r
+ if ((ContextToSave != NULL) && (Framework->CurrentTest != NULL)) {\r
+ TestSaveContext = (UNIT_TEST_SAVE_CONTEXT *)FloatingPointer;\r
+ TestSaveContext->Size = (UINT32)ContextToSaveSize + sizeof (UNIT_TEST_SAVE_CONTEXT);\r
CopyMem (&TestSaveContext->Fingerprint[0], &Framework->CurrentTest->Fingerprint[0], UNIT_TEST_FINGERPRINT_SIZE);\r
CopyMem (((UINT8 *)TestSaveContext + sizeof (UNIT_TEST_SAVE_CONTEXT)), ContextToSave, ContextToSaveSize);\r
Header->HasSavedContext = TRUE;\r
EFI_STATUS\r
EFIAPI\r
SaveFrameworkState (\r
- IN UNIT_TEST_CONTEXT ContextToSave OPTIONAL,\r
- IN UINTN ContextToSaveSize\r
+ IN UNIT_TEST_CONTEXT ContextToSave OPTIONAL,\r
+ IN UINTN ContextToSaveSize\r
)\r
{\r
EFI_STATUS Status;\r
UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle;\r
UNIT_TEST_SAVE_HEADER *Header;\r
\r
- Header = NULL;\r
+ Header = NULL;\r
FrameworkHandle = GetActiveFrameworkHandle ();\r
\r
//\r
//\r
// First, let's not make assumptions about the parameters.\r
//\r
- if ((ContextToSave != NULL && ContextToSaveSize == 0) ||\r
- ContextToSaveSize > MAX_UINT32) {\r
+ if (((ContextToSave != NULL) && (ContextToSaveSize == 0)) ||\r
+ (ContextToSaveSize > MAX_UINT32))\r
+ {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
\r
**/\r
STATIC\r
-EFI_DEVICE_PATH_PROTOCOL*\r
+EFI_DEVICE_PATH_PROTOCOL *\r
GetCacheFileDevicePath (\r
IN UNIT_TEST_FRAMEWORK_HANDLE FrameworkHandle\r
)\r
UINTN CacheFilePathLength;\r
EFI_DEVICE_PATH_PROTOCOL *CacheFileDevicePath;\r
\r
- Framework = (UNIT_TEST_FRAMEWORK*)FrameworkHandle;\r
+ Framework = (UNIT_TEST_FRAMEWORK *)FrameworkHandle;\r
AppPath = NULL;\r
CacheFilePath = NULL;\r
TestName = NULL;\r
Status = gBS->HandleProtocol (\r
gImageHandle,\r
&gEfiLoadedImageProtocolGuid,\r
- (VOID**)&LoadedImage\r
+ (VOID **)&LoadedImage\r
);\r
if (EFI_ERROR (Status)) {\r
DEBUG ((DEBUG_WARN, "%a - Failed to locate DevicePath for loaded image. %r\n", __FUNCTION__, Status));\r
// Before we can start, change test name from ASCII to Unicode.\r
//\r
CacheFilePathLength = AsciiStrLen (Framework->ShortTitle) + 1;\r
- TestName = AllocatePool (CacheFilePathLength * sizeof(CHAR16));\r
+ TestName = AllocatePool (CacheFilePathLength * sizeof (CHAR16));\r
if (!TestName) {\r
goto Exit;\r
}\r
+\r
AsciiStrToUnicodeStrS (Framework->ShortTitle, TestName, CacheFilePathLength);\r
\r
//\r
// PathCleanUpDirectories (FileNameCopy);\r
// if (PathRemoveLastItem (FileNameCopy)) {\r
//\r
- AppPath = ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE); // NOTE: This must be freed.\r
+ AppPath = ConvertDevicePathToText (LoadedImage->FilePath, TRUE, TRUE); // NOTE: This must be freed.\r
DirectorySlashOffset = StrLen (AppPath);\r
//\r
// Make sure we didn't get any weird data.\r
if (AppPath[DirectorySlashOffset] == L'\\') {\r
break;\r
}\r
+\r
DirectorySlashOffset--;\r
} while (DirectorySlashOffset > 0);\r
\r
//\r
// Now we know some things, we're ready to produce our output string, I think.\r
//\r
- CacheFilePathLength = DirectorySlashOffset + 1;\r
+ CacheFilePathLength = DirectorySlashOffset + 1;\r
CacheFilePathLength += StrLen (TestName);\r
CacheFilePathLength += StrLen (CACHE_FILE_SUFFIX);\r
CacheFilePathLength += 1; // Don't forget the NULL terminator.\r
- CacheFilePath = AllocateZeroPool (CacheFilePathLength * sizeof (CHAR16));\r
+ CacheFilePath = AllocateZeroPool (CacheFilePathLength * sizeof (CHAR16));\r
if (!CacheFilePath) {\r
goto Exit;\r
}\r
//\r
StrnCpyS (CacheFilePath, CacheFilePathLength, AppPath, DirectorySlashOffset + 1); // Copy the path for the parent directory.\r
StrCatS (CacheFilePath, CacheFilePathLength, TestName); // Copy the base name for the test cache.\r
- StrCatS (CacheFilePath, CacheFilePathLength, CACHE_FILE_SUFFIX); // Copy the file suffix.\r
+ StrCatS (CacheFilePath, CacheFilePathLength, CACHE_FILE_SUFFIX); // Copy the file suffix.\r
\r
//\r
// Finally, try to create the device path for the thing thing.\r
if (AppPath != NULL) {\r
FreePool (AppPath);\r
}\r
+\r
if (CacheFilePath != NULL) {\r
FreePool (CacheFilePath);\r
}\r
+\r
if (TestName != NULL) {\r
FreePool (TestName);\r
}\r
//\r
// Check the inputs for sanity.\r
//\r
- if (FrameworkHandle == NULL || SaveData == NULL) {\r
+ if ((FrameworkHandle == NULL) || (SaveData == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
FileDevicePath = GetCacheFileDevicePath (FrameworkHandle);\r
\r
//\r
- //First lets open the file if it exists so we can delete it...This is the work around for truncation\r
+ // First lets open the file if it exists so we can delete it...This is the work around for truncation\r
//\r
Status = ShellOpenFileByDevicePath (\r
&FileDevicePath,\r
SaveData\r
);\r
\r
- if (EFI_ERROR (Status) || WriteCount != SaveData->SaveStateSize) {\r
+ if (EFI_ERROR (Status) || (WriteCount != SaveData->SaveStateSize)) {\r
DEBUG ((DEBUG_ERROR, "%a - Writing to file failed! %r\n", __FUNCTION__, Status));\r
} else {\r
DEBUG ((DEBUG_INFO, "%a - SUCCESS!\n", __FUNCTION__));\r
//\r
// Check the inputs for sanity.\r
//\r
- if (FrameworkHandle == NULL || SaveData == NULL) {\r
+ if ((FrameworkHandle == NULL) || (SaveData == NULL)) {\r
return EFI_INVALID_PARAMETER;\r
}\r
\r
// Now that we know the size, let's allocated a buffer to hold the contents.\r
//\r
FileSize = (UINTN)LargeFileSize; // You know what... if it's too large, this lib don't care.\r
- Buffer = AllocatePool (FileSize);\r
+ Buffer = AllocatePool (FileSize);\r
if (Buffer == NULL) {\r
DEBUG ((DEBUG_ERROR, "%a - Failed to allocate a pool to hold the file contents! %r\n", __FUNCTION__, Status));\r
Status = EFI_OUT_OF_RESOURCES;\r
if (FileDevicePath != NULL) {\r
FreePool (FileDevicePath);\r
}\r
+\r
if (IsFileOpened) {\r
ShellCloseFile (&FileHandle);\r
}\r
//\r
// If we're returning an error, make sure\r
// the state is sane.\r
- if (EFI_ERROR (Status) && Buffer != NULL) {\r
+ if (EFI_ERROR (Status) && (Buffer != NULL)) {\r
FreePool (Buffer);\r
Buffer = NULL;\r
}\r
);\r
\r
struct _UNIT_TEST_STATUS_STRING {\r
- UNIT_TEST_STATUS Status;\r
- CHAR8 *String;\r
+ UNIT_TEST_STATUS Status;\r
+ CHAR8 *String;\r
};\r
\r
struct _UNIT_TEST_FAILURE_TYPE_STRING {\r
- FAILURE_TYPE Type;\r
- CHAR8 *String;\r
+ FAILURE_TYPE Type;\r
+ CHAR8 *String;\r
};\r
\r
struct _UNIT_TEST_STATUS_STRING mStatusStrings[] = {\r
- { UNIT_TEST_PASSED, "PASSED"},\r
- { UNIT_TEST_ERROR_PREREQUISITE_NOT_MET, "NOT RUN - PREREQUISITE FAILED"},\r
- { UNIT_TEST_ERROR_TEST_FAILED, "FAILED"},\r
- { UNIT_TEST_RUNNING, "RUNNING"},\r
- { UNIT_TEST_PENDING, "PENDING"},\r
- { 0, "**UNKNOWN**"}\r
+ { UNIT_TEST_PASSED, "PASSED" },\r
+ { UNIT_TEST_ERROR_PREREQUISITE_NOT_MET, "NOT RUN - PREREQUISITE FAILED" },\r
+ { UNIT_TEST_ERROR_TEST_FAILED, "FAILED" },\r
+ { UNIT_TEST_RUNNING, "RUNNING" },\r
+ { UNIT_TEST_PENDING, "PENDING" },\r
+ { 0, "**UNKNOWN**" }\r
};\r
\r
-struct _UNIT_TEST_FAILURE_TYPE_STRING mFailureTypeStrings[] = {\r
- { FAILURETYPE_NOFAILURE, "NO FAILURE"},\r
- { FAILURETYPE_OTHER, "OTHER FAILURE"},\r
- { FAILURETYPE_ASSERTTRUE, "ASSERT_TRUE FAILURE"},\r
- { FAILURETYPE_ASSERTFALSE, "ASSERT_FALSE FAILURE"},\r
- { FAILURETYPE_ASSERTEQUAL, "ASSERT_EQUAL FAILURE"},\r
- { FAILURETYPE_ASSERTNOTEQUAL, "ASSERT_NOTEQUAL FAILURE"},\r
- { FAILURETYPE_ASSERTNOTEFIERROR, "ASSERT_NOTEFIERROR FAILURE"},\r
- { FAILURETYPE_ASSERTSTATUSEQUAL, "ASSERT_STATUSEQUAL FAILURE"},\r
- { FAILURETYPE_ASSERTNOTNULL, "ASSERT_NOTNULL FAILURE"},\r
- { FAILURETYPE_EXPECTASSERT, "EXPECT_ASSERT FAILURE"},\r
- { 0, "*UNKNOWN* Failure"}\r
+struct _UNIT_TEST_FAILURE_TYPE_STRING mFailureTypeStrings[] = {\r
+ { FAILURETYPE_NOFAILURE, "NO FAILURE" },\r
+ { FAILURETYPE_OTHER, "OTHER FAILURE" },\r
+ { FAILURETYPE_ASSERTTRUE, "ASSERT_TRUE FAILURE" },\r
+ { FAILURETYPE_ASSERTFALSE, "ASSERT_FALSE FAILURE" },\r
+ { FAILURETYPE_ASSERTEQUAL, "ASSERT_EQUAL FAILURE" },\r
+ { FAILURETYPE_ASSERTNOTEQUAL, "ASSERT_NOTEQUAL FAILURE" },\r
+ { FAILURETYPE_ASSERTNOTEFIERROR, "ASSERT_NOTEFIERROR FAILURE" },\r
+ { FAILURETYPE_ASSERTSTATUSEQUAL, "ASSERT_STATUSEQUAL FAILURE" },\r
+ { FAILURETYPE_ASSERTNOTNULL, "ASSERT_NOTNULL FAILURE" },\r
+ { FAILURETYPE_EXPECTASSERT, "EXPECT_ASSERT FAILURE" },\r
+ { 0, "*UNKNOWN* Failure" }\r
};\r
\r
//\r
//\r
\r
STATIC\r
-CONST CHAR8*\r
+CONST CHAR8 *\r
GetStringForUnitTestStatus (\r
IN UNIT_TEST_STATUS Status\r
)\r
return mStatusStrings[Index].String;\r
}\r
}\r
+\r
//\r
// Return last entry if no match found.\r
//\r
}\r
\r
STATIC\r
-CONST CHAR8*\r
+CONST CHAR8 *\r
GetStringForFailureType (\r
IN FAILURE_TYPE Failure\r
)\r
return mFailureTypeStrings[Index].String;\r
}\r
}\r
+\r
//\r
// Return last entry if no match found.\r
//\r
- DEBUG((DEBUG_INFO, "%a Failure Type does not have string defined 0x%X\n", __FUNCTION__, (UINT32)Failure));\r
+ DEBUG ((DEBUG_INFO, "%a Failure Type does not have string defined 0x%X\n", __FUNCTION__, (UINT32)Failure));\r
return mFailureTypeStrings[Index].String;\r
}\r
\r
Passed = 0;\r
Failed = 0;\r
NotRun = 0;\r
- Suite = NULL;\r
+ Suite = NULL;\r
\r
Framework = (UNIT_TEST_FRAMEWORK *)FrameworkHandle;\r
if (Framework == NULL) {\r
ReportPrint ("------------- UNIT TEST FRAMEWORK RESULTS ---------------\n");\r
ReportPrint ("---------------------------------------------------------\n");\r
\r
- //print the version and time\r
+ // print the version and time\r
\r
//\r
// Iterate all suites\r
//\r
- for (Suite = (UNIT_TEST_SUITE_LIST_ENTRY*)GetFirstNode(&Framework->TestSuiteList);\r
- (LIST_ENTRY*)Suite != &Framework->TestSuiteList;\r
- Suite = (UNIT_TEST_SUITE_LIST_ENTRY*)GetNextNode(&Framework->TestSuiteList, (LIST_ENTRY*)Suite)) {\r
-\r
- Test = NULL;\r
+ for (Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetFirstNode (&Framework->TestSuiteList);\r
+ (LIST_ENTRY *)Suite != &Framework->TestSuiteList;\r
+ Suite = (UNIT_TEST_SUITE_LIST_ENTRY *)GetNextNode (&Framework->TestSuiteList, (LIST_ENTRY *)Suite))\r
+ {\r
+ Test = NULL;\r
SPassed = 0;\r
SFailed = 0;\r
SNotRun = 0;\r
//\r
// Iterate all tests within the suite\r
//\r
- for (Test = (UNIT_TEST_LIST_ENTRY*)GetFirstNode(&(Suite->UTS.TestCaseList));\r
- (LIST_ENTRY*)Test != &(Suite->UTS.TestCaseList);\r
- Test = (UNIT_TEST_LIST_ENTRY*)GetNextNode(&(Suite->UTS.TestCaseList), (LIST_ENTRY*)Test)) {\r
-\r
+ for (Test = (UNIT_TEST_LIST_ENTRY *)GetFirstNode (&(Suite->UTS.TestCaseList));\r
+ (LIST_ENTRY *)Test != &(Suite->UTS.TestCaseList);\r
+ Test = (UNIT_TEST_LIST_ENTRY *)GetNextNode (&(Suite->UTS.TestCaseList), (LIST_ENTRY *)Test))\r
+ {\r
ReportPrint ("*********************************************************\n");\r
ReportPrint (" CLASS NAME: %a\n", Test->UT.Name);\r
ReportPrint (" TEST: %a\n", Test->UT.Description);\r
}\r
\r
switch (Test->UT.Result) {\r
- case UNIT_TEST_PASSED:\r
- SPassed++;\r
- break;\r
- case UNIT_TEST_ERROR_TEST_FAILED:\r
- SFailed++;\r
- break;\r
- case UNIT_TEST_PENDING: // Fall through...\r
- case UNIT_TEST_RUNNING: // Fall through...\r
- case UNIT_TEST_ERROR_PREREQUISITE_NOT_MET:\r
- SNotRun++;\r
- break;\r
- default:\r
- break;\r
+ case UNIT_TEST_PASSED:\r
+ SPassed++;\r
+ break;\r
+ case UNIT_TEST_ERROR_TEST_FAILED:\r
+ SFailed++;\r
+ break;\r
+ case UNIT_TEST_PENDING: // Fall through...\r
+ case UNIT_TEST_RUNNING: // Fall through...\r
+ case UNIT_TEST_ERROR_PREREQUISITE_NOT_MET:\r
+ SNotRun++;\r
+ break;\r
+ default:\r
+ break;\r
}\r
+\r
ReportPrint ("**********************************************************\n");\r
- } //End Test iteration\r
+ } // End Test iteration\r
\r
ReportPrint ("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");\r
ReportPrint ("Suite Stats\n");\r
ReportPrint (" Passed: %d (%d%%)\n", SPassed, (SPassed * 100)/(SPassed+SFailed+SNotRun));\r
ReportPrint (" Failed: %d (%d%%)\n", SFailed, (SFailed * 100) / (SPassed + SFailed + SNotRun));\r
ReportPrint (" Not Run: %d (%d%%)\n", SNotRun, (SNotRun * 100) / (SPassed + SFailed + SNotRun));\r
- ReportPrint ("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n" );\r
+ ReportPrint ("+++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n");\r
\r
- Passed += SPassed; //add to global counters\r
- Failed += SFailed; //add to global counters\r
- NotRun += SNotRun; //add to global counters\r
- }//End Suite iteration\r
+ Passed += SPassed; // add to global counters\r
+ Failed += SFailed; // add to global counters\r
+ NotRun += SNotRun; // add to global counters\r
+ }// End Suite iteration\r
\r
ReportPrint ("=========================================================\n");\r
ReportPrint ("Total Stats\n");\r
ReportPrint (" Passed: %d (%d%%)\n", Passed, (Passed * 100) / (Passed + Failed + NotRun));\r
ReportPrint (" Failed: %d (%d%%)\n", Failed, (Failed * 100) / (Passed + Failed + NotRun));\r
ReportPrint (" Not Run: %d (%d%%)\n", NotRun, (NotRun * 100) / (Passed + Failed + NotRun));\r
- ReportPrint ("=========================================================\n" );\r
+ ReportPrint ("=========================================================\n");\r
\r
return EFI_SUCCESS;\r
}\r
} else {\r
gST->ConOut->OutputString (gST->ConOut, String);\r
}\r
+\r
VA_END (Marker);\r
}\r
\r
} else {\r
DEBUG ((DEBUG_INFO, String));\r
}\r
+\r
VA_END (Marker);\r
}\r
\r
\r
#include <UnitTestFrameworkTypes.h>\r
\r
-#define UNIT_TEST_PERSISTENCE_LIB_VERSION 1\r
+#define UNIT_TEST_PERSISTENCE_LIB_VERSION 1\r
\r
/**\r
Determines whether a persistence cache already exists for\r
///\r
/// The maximum length of a string stored in the unit test framework\r
///\r
-#define UNIT_TEST_MAX_STRING_LENGTH (120)\r
+#define UNIT_TEST_MAX_STRING_LENGTH (120)\r
\r
///\r
/// The size of a firngerprint used to save/resume execution of a unit test\r
/// framework. This is the size of a CRC32 value which is 32-bit value.\r
///\r
///\r
-#define UNIT_TEST_FINGERPRINT_SIZE (sizeof (UINT32))\r
+#define UNIT_TEST_FINGERPRINT_SIZE (sizeof (UINT32))\r
\r
///\r
/// The maximum length of a test failure message stored in the unit test\r
/// test.\r
///\r
typedef UINT32 FAILURE_TYPE;\r
-#define FAILURETYPE_NOFAILURE (0)\r
-#define FAILURETYPE_OTHER (1)\r
-#define FAILURETYPE_ASSERTTRUE (2)\r
-#define FAILURETYPE_ASSERTFALSE (3)\r
-#define FAILURETYPE_ASSERTEQUAL (4)\r
-#define FAILURETYPE_ASSERTNOTEQUAL (5)\r
-#define FAILURETYPE_ASSERTNOTEFIERROR (6)\r
-#define FAILURETYPE_ASSERTSTATUSEQUAL (7)\r
-#define FAILURETYPE_ASSERTNOTNULL (8)\r
-#define FAILURETYPE_EXPECTASSERT (9)\r
+#define FAILURETYPE_NOFAILURE (0)\r
+#define FAILURETYPE_OTHER (1)\r
+#define FAILURETYPE_ASSERTTRUE (2)\r
+#define FAILURETYPE_ASSERTFALSE (3)\r
+#define FAILURETYPE_ASSERTEQUAL (4)\r
+#define FAILURETYPE_ASSERTNOTEQUAL (5)\r
+#define FAILURETYPE_ASSERTNOTEFIERROR (6)\r
+#define FAILURETYPE_ASSERTSTATUSEQUAL (7)\r
+#define FAILURETYPE_ASSERTNOTNULL (8)\r
+#define FAILURETYPE_EXPECTASSERT (9)\r
\r
///\r
/// Unit Test context structure tracked by the unit test framework.\r
///\r
typedef struct {\r
- CHAR8 *Description;\r
- CHAR8 *Name; //can't have spaces and should be short\r
- CHAR8 *Log;\r
- FAILURE_TYPE FailureType;\r
- CHAR8 FailureMessage[UNIT_TEST_TESTFAILUREMSG_LENGTH];\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
- UNIT_TEST_STATUS Result;\r
- UNIT_TEST_FUNCTION RunTest;\r
- UNIT_TEST_PREREQUISITE Prerequisite;\r
- UNIT_TEST_CLEANUP CleanUp;\r
- UNIT_TEST_CONTEXT Context;\r
- UNIT_TEST_SUITE_HANDLE ParentSuite;\r
+ CHAR8 *Description;\r
+ CHAR8 *Name; // can't have spaces and should be short\r
+ CHAR8 *Log;\r
+ FAILURE_TYPE FailureType;\r
+ CHAR8 FailureMessage[UNIT_TEST_TESTFAILUREMSG_LENGTH];\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
+ UNIT_TEST_STATUS Result;\r
+ UNIT_TEST_FUNCTION RunTest;\r
+ UNIT_TEST_PREREQUISITE Prerequisite;\r
+ UNIT_TEST_CLEANUP CleanUp;\r
+ UNIT_TEST_CONTEXT Context;\r
+ UNIT_TEST_SUITE_HANDLE ParentSuite;\r
} UNIT_TEST;\r
\r
///\r
/// Structure used to store the set of unit tests in a unit test suite as a list.\r
///\r
typedef struct {\r
- LIST_ENTRY Entry;\r
- UNIT_TEST UT;\r
+ LIST_ENTRY Entry;\r
+ UNIT_TEST UT;\r
} UNIT_TEST_LIST_ENTRY;\r
\r
///\r
/// Unit Test Suite context structure tracked by the unit test framework.\r
///\r
typedef struct {\r
- UINTN NumTests;\r
- CHAR8 *Title;\r
- CHAR8 *Name;\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
- UNIT_TEST_SUITE_SETUP Setup;\r
- UNIT_TEST_SUITE_TEARDOWN Teardown;\r
- LIST_ENTRY TestCaseList; // UNIT_TEST_LIST_ENTRY\r
- UNIT_TEST_FRAMEWORK_HANDLE ParentFramework;\r
+ UINTN NumTests;\r
+ CHAR8 *Title;\r
+ CHAR8 *Name;\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
+ UNIT_TEST_SUITE_SETUP Setup;\r
+ UNIT_TEST_SUITE_TEARDOWN Teardown;\r
+ LIST_ENTRY TestCaseList; // UNIT_TEST_LIST_ENTRY\r
+ UNIT_TEST_FRAMEWORK_HANDLE ParentFramework;\r
} UNIT_TEST_SUITE;\r
\r
///\r
/// as a list.\r
///\r
typedef struct {\r
- LIST_ENTRY Entry;\r
- UNIT_TEST_SUITE UTS;\r
+ LIST_ENTRY Entry;\r
+ UNIT_TEST_SUITE UTS;\r
} UNIT_TEST_SUITE_LIST_ENTRY;\r
\r
///\r
/// Unit Test Framework context structure tracked by the unit test framework.\r
///\r
typedef struct {\r
- CHAR8 *Title;\r
- CHAR8 *ShortTitle; // This title should contain NO spaces or non-filename characters. Is used in reporting and serialization.\r
- CHAR8 *VersionString;\r
- CHAR8 *Log;\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
- LIST_ENTRY TestSuiteList; // UNIT_TEST_SUITE_LIST_ENTRY\r
- EFI_TIME StartTime;\r
- EFI_TIME EndTime;\r
- UNIT_TEST *CurrentTest;\r
- VOID *SavedState; // This is an instance of UNIT_TEST_SAVE_HEADER*, if present.\r
+ CHAR8 *Title;\r
+ CHAR8 *ShortTitle; // This title should contain NO spaces or non-filename characters. Is used in reporting and serialization.\r
+ CHAR8 *VersionString;\r
+ CHAR8 *Log;\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE];\r
+ LIST_ENTRY TestSuiteList; // UNIT_TEST_SUITE_LIST_ENTRY\r
+ EFI_TIME StartTime;\r
+ EFI_TIME EndTime;\r
+ UNIT_TEST *CurrentTest;\r
+ VOID *SavedState; // This is an instance of UNIT_TEST_SAVE_HEADER*, if present.\r
} UNIT_TEST_FRAMEWORK;\r
\r
///\r
/// Serialized version of a unit test\r
///\r
typedef struct {\r
- UINT32 Size; // Size of the UNIT_TEST_SAVE_TEST including Log[]\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the test itself.\r
- CHAR8 FailureMessage[UNIT_TEST_TESTFAILUREMSG_LENGTH];\r
- FAILURE_TYPE FailureType;\r
- UNIT_TEST_STATUS Result;\r
- CHAR8 Log[];\r
+ UINT32 Size; // Size of the UNIT_TEST_SAVE_TEST including Log[]\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the test itself.\r
+ CHAR8 FailureMessage[UNIT_TEST_TESTFAILUREMSG_LENGTH];\r
+ FAILURE_TYPE FailureType;\r
+ UNIT_TEST_STATUS Result;\r
+ CHAR8 Log[];\r
} UNIT_TEST_SAVE_TEST;\r
\r
///\r
/// Serialized version of a unit test context\r
///\r
typedef struct {\r
- UINT32 Size; // Size of the UNIT_TEST_SAVE_CONTEXT including Data[]\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the corresponding test.\r
- UINT8 Data[]; // Actual data of the context.\r
+ UINT32 Size; // Size of the UNIT_TEST_SAVE_CONTEXT including Data[]\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the corresponding test.\r
+ UINT8 Data[]; // Actual data of the context.\r
} UNIT_TEST_SAVE_CONTEXT;\r
\r
///\r
/// Serialized version of unit test framework\r
///\r
typedef struct {\r
- UINT8 Version;\r
- UINT32 SaveStateSize; // Size of the entire serialized buffer.\r
- UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the framework that has been saved.\r
- EFI_TIME StartTime;\r
- UINT32 TestCount;\r
- BOOLEAN HasSavedContext;\r
+ UINT8 Version;\r
+ UINT32 SaveStateSize; // Size of the entire serialized buffer.\r
+ UINT8 Fingerprint[UNIT_TEST_FINGERPRINT_SIZE]; // Fingerprint of the framework that has been saved.\r
+ EFI_TIME StartTime;\r
+ UINT32 TestCount;\r
+ BOOLEAN HasSavedContext;\r
// UNIT_TEST_SAVE_TEST Tests[]; // Array of structures starts here.\r
// UNIT_TEST_SAVE_CONTEXT SavedContext[]; // Saved context for the currently running test.\r
// CHAR8 Log[]; // NOTE: Not yet implemented!!\r
\r
Framework = NULL;\r
\r
- DEBUG(( DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION ));\r
+ DEBUG ((DEBUG_INFO, "%a v%a\n", UNIT_TEST_NAME, UNIT_TEST_VERSION));\r
\r
//\r
// Start setting up the test framework for running the tests.\r
//\r
Status = InitUnitTestFramework (&Framework, UNIT_TEST_NAME, gEfiCallerBaseName, UNIT_TEST_VERSION);\r
if (EFI_ERROR (Status)) {\r
- DEBUG((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));\r
+ DEBUG ((DEBUG_ERROR, "Failed in InitUnitTestFramework. Status = %r\n", Status));\r
goto EXIT;\r
}\r
\r
Status = EFI_OUT_OF_RESOURCES;\r
goto EXIT;\r
}\r
+\r
AddTestCase (SimpleMathTests, "Adding 1 to 1 should produce 2", "Addition", OnePlusOneShouldEqualTwo, NULL, NULL, NULL);\r
\r
//\r
Status = EFI_OUT_OF_RESOURCES;\r
goto EXIT;\r
}\r
+\r
AddTestCase (GlobalVarTests, "You should be able to change a global BOOLEAN", "Boolean", GlobalBooleanShouldBeChangeable, NULL, NULL, NULL);\r
AddTestCase (GlobalVarTests, "You should be able to change a global pointer", "Pointer", GlobalPointerShouldBeChangeable, MakeSureThatPointerIsNull, ClearThePointer, NULL);\r
\r
Status = EFI_OUT_OF_RESOURCES;\r
goto EXIT;\r
}\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_TRUE() macro", "MacroUtAssertTrue", MacroUtAssertTrue, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_FALSE() macro", "MacroUtAssertFalse", MacroUtAssertFalse, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_EQUAL() macro", "MacroUtAssertEqual", MacroUtAssertEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_MEM_EQUAL() macro", "MacroUtAssertMemEqual", MacroUtAssertMemEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_EQUAL() macro", "MacroUtAssertNotEqual", MacroUtAssertNotEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_EFI_ERROR() macro", "MacroUtAssertNotEfiError", MacroUtAssertNotEfiError, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_STATUS_EQUAL() macro", "MacroUtAssertStatusEqual", MacroUtAssertStatusEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_NULL() macro", "MacroUtAssertNotNull", MacroUtAssertNotNull, NULL, NULL, NULL);\r
+\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_TRUE() macro", "MacroUtAssertTrue", MacroUtAssertTrue, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_FALSE() macro", "MacroUtAssertFalse", MacroUtAssertFalse, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_EQUAL() macro", "MacroUtAssertEqual", MacroUtAssertEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_MEM_EQUAL() macro", "MacroUtAssertMemEqual", MacroUtAssertMemEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_EQUAL() macro", "MacroUtAssertNotEqual", MacroUtAssertNotEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_EFI_ERROR() macro", "MacroUtAssertNotEfiError", MacroUtAssertNotEfiError, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_STATUS_EQUAL() macro", "MacroUtAssertStatusEqual", MacroUtAssertStatusEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_ASSERT_NOT_NULL() macro", "MacroUtAssertNotNull", MacroUtAssertNotNull, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsEnabled, "Test UT_EXPECT_ASSERT_FAILURE() macro", "MacroUtExpectAssertFailure", MacroUtExpectAssertFailure, NULL, NULL, NULL);\r
\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_ERROR() macro", "MacroUtLogError", MacroUtLogError, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_ERROR() macro", "MacroUtLogError", MacroUtLogError, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_WARNING() macro", "MacroUtLogWarning", MacroUtLogWarning, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_INFO() macro", "MacroUtLogInfo", MacroUtLogInfo, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_INFO() macro", "MacroUtLogInfo", MacroUtLogInfo, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsEnabled, "Test UT_LOG_VERBOSE() macro", "MacroUtLogVerbose", MacroUtLogVerbose, NULL, NULL, NULL);\r
\r
//\r
Status = EFI_OUT_OF_RESOURCES;\r
goto EXIT;\r
}\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_TRUE() macro", "MacroUtAssertTrue", MacroUtAssertTrue, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_FALSE() macro", "MacroUtAssertFalse", MacroUtAssertFalse, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_EQUAL() macro", "MacroUtAssertEqual", MacroUtAssertEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_MEM_EQUAL() macro", "MacroUtAssertMemEqual", MacroUtAssertMemEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_EQUAL() macro", "MacroUtAssertNotEqual", MacroUtAssertNotEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_EFI_ERROR() macro", "MacroUtAssertNotEfiError", MacroUtAssertNotEfiError, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_STATUS_EQUAL() macro", "MacroUtAssertStatusEqual", MacroUtAssertStatusEqual, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_NULL() macro", "MacroUtAssertNotNull", MacroUtAssertNotNull, NULL, NULL, NULL);\r
+\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_TRUE() macro", "MacroUtAssertTrue", MacroUtAssertTrue, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_FALSE() macro", "MacroUtAssertFalse", MacroUtAssertFalse, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_EQUAL() macro", "MacroUtAssertEqual", MacroUtAssertEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_MEM_EQUAL() macro", "MacroUtAssertMemEqual", MacroUtAssertMemEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_EQUAL() macro", "MacroUtAssertNotEqual", MacroUtAssertNotEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_EFI_ERROR() macro", "MacroUtAssertNotEfiError", MacroUtAssertNotEfiError, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_STATUS_EQUAL() macro", "MacroUtAssertStatusEqual", MacroUtAssertStatusEqual, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_ASSERT_NOT_NULL() macro", "MacroUtAssertNotNull", MacroUtAssertNotNull, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsDisabled, "Test UT_EXPECT_ASSERT_FAILURE() macro", "MacroUtExpectAssertFailure", MacroUtExpectAssertFailure, NULL, NULL, NULL);\r
\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_ERROR() macro", "MacroUtLogError", MacroUtLogError, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_ERROR() macro", "MacroUtLogError", MacroUtLogError, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_WARNING() macro", "MacroUtLogWarning", MacroUtLogWarning, NULL, NULL, NULL);\r
- AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_INFO() macro", "MacroUtLogInfo", MacroUtLogInfo, NULL, NULL, NULL);\r
+ AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_INFO() macro", "MacroUtLogInfo", MacroUtLogInfo, NULL, NULL, NULL);\r
AddTestCase (MacroTestsAssertsDisabled, "Test UT_LOG_VERBOSE() macro", "MacroUtLogVerbose", MacroUtLogVerbose, NULL, NULL, NULL);\r
\r
//\r
**/\r
int\r
main (\r
- int argc,\r
- char *argv[]\r
+ int argc,\r
+ char *argv[]\r
)\r
{\r
return UefiTestMain ();\r
projects / mirror_edk2.git / commitdiff