diff --git a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.cpp b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.cpp index 6fbf302c1c..3f50f0cd99 100644 --- a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.cpp +++ b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests32.cpp @@ -14,10 +14,10 @@ extern "C" { #include } -TEST(ConversionTestSuite, TestSafeInt32ToUintn) { +TEST (ConversionTestSuite, TestSafeInt32ToUintn) { RETURN_STATUS Status; - INT32 Operand; - UINTN Result; + INT32 Operand; + UINTN Result; // // If Operand is non-negative, then it's a cast @@ -36,10 +36,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToIntn) { +TEST (ConversionTestSuite, TestSafeUint32ToIntn) { RETURN_STATUS Status; - UINT32 Operand; - INTN Result; + UINT32 Operand; + INTN Result; // // If Operand is <= MAX_INTN, then it's a cast @@ -58,10 +58,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToInt32) { +TEST (ConversionTestSuite, TestSafeIntnToInt32) { RETURN_STATUS Status; - INTN Operand; - INT32 Result; + INTN Operand; + INT32 Result; // // INTN is same as INT32 in IA32, so this is just a cast @@ -73,10 +73,10 @@ TEST(ConversionTestSuite, TestSafeIntnToInt32) { ASSERT_EQ (0x5bababab, Result); } -TEST(ConversionTestSuite, TestSafeIntnToUint32) { +TEST (ConversionTestSuite, TestSafeIntnToUint32) { RETURN_STATUS Status; - INTN Operand; - UINT32 Result; + INTN Operand; + UINT32 Result; // // If Operand is non-negative, then it's a cast @@ -95,10 +95,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToUint32) { +TEST (ConversionTestSuite, TestSafeUintnToUint32) { RETURN_STATUS Status; - UINTN Operand; - UINT32 Result; + UINTN Operand; + UINT32 Result; // // UINTN is same as UINT32 in IA32, so this is just a cast @@ -110,10 +110,10 @@ TEST(ConversionTestSuite, TestSafeUintnToUint32) { ASSERT_EQ (0xabababab, Result); } -TEST(ConversionTestSuite, TestSafeUintnToIntn) { +TEST (ConversionTestSuite, TestSafeUintnToIntn) { RETURN_STATUS Status; - UINTN Operand; - INTN Result; + UINTN Operand; + INTN Result; // // If Operand is <= MAX_INTN, then it's a cast @@ -132,10 +132,10 @@ TEST(ConversionTestSuite, TestSafeUintnToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToInt64) { +TEST (ConversionTestSuite, TestSafeUintnToInt64) { RETURN_STATUS Status; - UINTN Operand; - INT64 Result; + UINTN Operand; + INT64 Result; // // UINTN is same as UINT32 in IA32, and UINT32 is a subset of @@ -148,10 +148,10 @@ TEST(ConversionTestSuite, TestSafeUintnToInt64) { ASSERT_EQ (0xabababab, Result); } -TEST(ConversionTestSuite, TestSafeInt64ToIntn) { +TEST (ConversionTestSuite, TestSafeInt64ToIntn) { RETURN_STATUS Status; - INT64 Operand; - INTN Result; + INT64 Operand; + INTN Result; // // If Operand is between MIN_INTN and MAX_INTN2 inclusive, then it's a cast @@ -179,10 +179,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToUintn) { +TEST (ConversionTestSuite, TestSafeInt64ToUintn) { RETURN_STATUS Status; - INT64 Operand; - UINTN Result; + INT64 Operand; + UINTN Result; // // If Operand is between 0 and MAX_UINTN inclusive, then it's a cast @@ -205,10 +205,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToIntn) { +TEST (ConversionTestSuite, TestSafeUint64ToIntn) { RETURN_STATUS Status; - UINT64 Operand; - INTN Result; + UINT64 Operand; + INTN Result; // // If Operand is <= MAX_INTN, then it's a cast @@ -227,10 +227,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToUintn) { +TEST (ConversionTestSuite, TestSafeUint64ToUintn) { RETURN_STATUS Status; - UINT64 Operand; - UINTN Result; + UINT64 Operand; + UINTN Result; // // If Operand is <= MAX_UINTN, then it's a cast @@ -249,11 +249,11 @@ TEST(ConversionTestSuite, TestSafeUint64ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) { +TEST (AdditionSubtractionTestSuite, TestSafeUintnAdd) { RETURN_STATUS Status; - UINTN Augend; - UINTN Addend; - UINTN Result; + UINTN Augend; + UINTN Addend; + UINTN Result; // // If the result of addition doesn't overflow MAX_UINTN, then it's addition @@ -274,11 +274,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) { +TEST (AdditionSubtractionTestSuite, TestSafeIntnAdd) { RETURN_STATUS Status; - INTN Augend; - INTN Addend; - INTN Result; + INTN Augend; + INTN Addend; + INTN Result; // // If the result of addition doesn't overflow MAX_INTN @@ -311,11 +311,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) { +TEST (AdditionSubtractionTestSuite, TestSafeUintnSub) { RETURN_STATUS Status; - UINTN Minuend; - UINTN Subtrahend; - UINTN Result; + UINTN Minuend; + UINTN Subtrahend; + UINTN Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -336,11 +336,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) { +TEST (AdditionSubtractionTestSuite, TestSafeIntnSub) { RETURN_STATUS Status; - INTN Minuend; - INTN Subtrahend; - INTN Result; + INTN Minuend; + INTN Subtrahend; + INTN Result; // // If the result of subtractions doesn't overflow MAX_INTN or @@ -373,11 +373,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeUintnMult) { +TEST (MultiplicationTestSuite, TestSafeUintnMult) { RETURN_STATUS Status; - UINTN Multiplicand; - UINTN Multiplier; - UINTN Result; + UINTN Multiplicand; + UINTN Multiplier; + UINTN Result; // // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed @@ -398,11 +398,11 @@ TEST(MultiplicationTestSuite, TestSafeUintnMult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeIntnMult) { +TEST (MultiplicationTestSuite, TestSafeIntnMult) { RETURN_STATUS Status; - INTN Multiplicand; - INTN Multiplier; - INTN Result; + INTN Multiplicand; + INTN Multiplier; + INTN Result; // // If the result of multiplication doesn't overflow MAX_INTN and doesn't diff --git a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.cpp b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.cpp index 6fb0710cfe..6efdd3be7c 100644 --- a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.cpp +++ b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/SafeIntLibUintnIntnUnitTests64.cpp @@ -14,10 +14,10 @@ extern "C" { #include } -TEST(ConversionTestSuite, TestSafeInt32ToUintn) { +TEST (ConversionTestSuite, TestSafeInt32ToUintn) { RETURN_STATUS Status; - INT32 Operand; - UINTN Result; + INT32 Operand; + UINTN Result; // // If Operand is non-negative, then it's a cast @@ -36,10 +36,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToIntn) { +TEST (ConversionTestSuite, TestSafeUint32ToIntn) { RETURN_STATUS Status; - UINT32 Operand; - INTN Result; + UINT32 Operand; + INTN Result; // // For x64, INTN is same as INT64 which is a superset of INT32 @@ -56,10 +56,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToIntn) { ASSERT_EQ (0xabababab, Result); } -TEST(ConversionTestSuite, TestSafeIntnToInt32) { +TEST (ConversionTestSuite, TestSafeIntnToInt32) { RETURN_STATUS Status; - INTN Operand; - INT32 Result; + INTN Operand; + INT32 Result; // // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast @@ -87,10 +87,10 @@ TEST(ConversionTestSuite, TestSafeIntnToInt32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToUint32) { +TEST (ConversionTestSuite, TestSafeIntnToUint32) { RETURN_STATUS Status; - INTN Operand; - UINT32 Result; + INTN Operand; + UINT32 Result; // // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast @@ -113,10 +113,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToUint32) { +TEST (ConversionTestSuite, TestSafeUintnToUint32) { RETURN_STATUS Status; - UINTN Operand; - UINT32 Result; + UINTN Operand; + UINT32 Result; // // If Operand is <= MAX_UINT32, then it's a cast @@ -135,10 +135,10 @@ TEST(ConversionTestSuite, TestSafeUintnToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToIntn) { +TEST (ConversionTestSuite, TestSafeUintnToIntn) { RETURN_STATUS Status; - UINTN Operand; - INTN Result; + UINTN Operand; + INTN Result; // // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast @@ -157,10 +157,10 @@ TEST(ConversionTestSuite, TestSafeUintnToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToInt64) { +TEST (ConversionTestSuite, TestSafeUintnToInt64) { RETURN_STATUS Status; - UINTN Operand; - INT64 Result; + UINTN Operand; + INT64 Result; // // If Operand is <= MAX_INT64, then it's a cast @@ -179,10 +179,10 @@ TEST(ConversionTestSuite, TestSafeUintnToInt64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToIntn) { +TEST (ConversionTestSuite, TestSafeInt64ToIntn) { RETURN_STATUS Status; - INT64 Operand; - INTN Result; + INT64 Operand; + INTN Result; // // INTN is same as INT64 in x64, so this is just a cast @@ -194,10 +194,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToIntn) { ASSERT_EQ (0x5babababefefefef, Result); } -TEST(ConversionTestSuite, TestSafeInt64ToUintn) { +TEST (ConversionTestSuite, TestSafeInt64ToUintn) { RETURN_STATUS Status; - INT64 Operand; - UINTN Result; + INT64 Operand; + UINTN Result; // // If Operand is non-negative, then it's a cast @@ -216,10 +216,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToIntn) { +TEST (ConversionTestSuite, TestSafeUint64ToIntn) { RETURN_STATUS Status; - UINT64 Operand; - INTN Result; + UINT64 Operand; + INTN Result; // // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast @@ -238,10 +238,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToIntn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToUintn) { +TEST (ConversionTestSuite, TestSafeUint64ToUintn) { RETURN_STATUS Status; - UINT64 Operand; - UINTN Result; + UINT64 Operand; + UINTN Result; // // UINTN is same as UINT64 in x64, so this is just a cast @@ -253,11 +253,11 @@ TEST(ConversionTestSuite, TestSafeUint64ToUintn) { ASSERT_EQ (0xababababefefefef, Result); } -TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) { +TEST (AdditionSubtractionTestSuite, TestSafeUintnAdd) { RETURN_STATUS Status; - UINTN Augend; - UINTN Addend; - UINTN Result; + UINTN Augend; + UINTN Addend; + UINTN Result; // // If the result of addition doesn't overflow MAX_UINTN, then it's addition @@ -278,11 +278,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) { +TEST (AdditionSubtractionTestSuite, TestSafeIntnAdd) { RETURN_STATUS Status; - INTN Augend; - INTN Addend; - INTN Result; + INTN Augend; + INTN Addend; + INTN Result; // // If the result of addition doesn't overflow MAX_INTN @@ -315,11 +315,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) { +TEST (AdditionSubtractionTestSuite, TestSafeUintnSub) { RETURN_STATUS Status; - UINTN Minuend; - UINTN Subtrahend; - UINTN Result; + UINTN Minuend; + UINTN Subtrahend; + UINTN Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -340,11 +340,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) { +TEST (AdditionSubtractionTestSuite, TestSafeIntnSub) { RETURN_STATUS Status; - INTN Minuend; - INTN Subtrahend; - INTN Result; + INTN Minuend; + INTN Subtrahend; + INTN Result; // // If the result of subtractions doesn't overflow MAX_INTN or @@ -377,11 +377,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeUintnMult) { +TEST (MultiplicationTestSuite, TestSafeUintnMult) { RETURN_STATUS Status; - UINTN Multiplicand; - UINTN Multiplier; - UINTN Result; + UINTN Multiplicand; + UINTN Multiplier; + UINTN Result; // // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed @@ -402,11 +402,11 @@ TEST(MultiplicationTestSuite, TestSafeUintnMult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeIntnMult) { +TEST (MultiplicationTestSuite, TestSafeIntnMult) { RETURN_STATUS Status; - INTN Multiplicand; - INTN Multiplier; - INTN Result; + INTN Multiplicand; + INTN Multiplier; + INTN Result; // // If the result of multiplication doesn't overflow MAX_INTN and doesn't diff --git a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.cpp b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.cpp index 1fd51067a1..857ab4d1d3 100644 --- a/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.cpp +++ b/MdePkg/Test/GoogleTest/Library/BaseSafeIntLib/TestBaseSafeIntLib.cpp @@ -15,10 +15,10 @@ extern "C" { // // Conversion function tests: // -TEST(ConversionTestSuite, TestSafeInt8ToUint8) { +TEST (ConversionTestSuite, TestSafeInt8ToUint8) { RETURN_STATUS Status; - INT8 Operand; - UINT8 Result; + INT8 Operand; + UINT8 Result; // // Positive UINT8 should result in just a cast @@ -37,10 +37,10 @@ TEST(ConversionTestSuite, TestSafeInt8ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt8ToUint16) { +TEST (ConversionTestSuite, TestSafeInt8ToUint16) { RETURN_STATUS Status; - INT8 Operand; - UINT16 Result; + INT8 Operand; + UINT16 Result; // // Positive UINT8 should result in just a cast @@ -59,10 +59,10 @@ TEST(ConversionTestSuite, TestSafeInt8ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt8ToUint32) { +TEST (ConversionTestSuite, TestSafeInt8ToUint32) { RETURN_STATUS Status; - INT8 Operand; - UINT32 Result; + INT8 Operand; + UINT32 Result; // // Positive UINT8 should result in just a cast @@ -81,10 +81,10 @@ TEST(ConversionTestSuite, TestSafeInt8ToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt8ToUintn) { +TEST (ConversionTestSuite, TestSafeInt8ToUintn) { RETURN_STATUS Status; - INT8 Operand; - UINTN Result; + INT8 Operand; + UINTN Result; // // Positive UINT8 should result in just a cast @@ -103,10 +103,10 @@ TEST(ConversionTestSuite, TestSafeInt8ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt8ToUint64) { +TEST (ConversionTestSuite, TestSafeInt8ToUint64) { RETURN_STATUS Status; - INT8 Operand; - UINT64 Result; + INT8 Operand; + UINT64 Result; // // Positive UINT8 should result in just a cast @@ -125,10 +125,10 @@ TEST(ConversionTestSuite, TestSafeInt8ToUint64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint8ToInt8) { +TEST (ConversionTestSuite, TestSafeUint8ToInt8) { RETURN_STATUS Status; - UINT8 Operand; - INT8 Result; + UINT8 Operand; + INT8 Result; // // Operand <= 0x7F (MAX_INT8) should result in a cast @@ -147,10 +147,10 @@ TEST(ConversionTestSuite, TestSafeUint8ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint8ToChar8) { +TEST (ConversionTestSuite, TestSafeUint8ToChar8) { RETURN_STATUS Status; - UINT8 Operand; - CHAR8 Result; + UINT8 Operand; + CHAR8 Result; // // CHAR8 is typedefed as char, which by default is signed, thus @@ -174,10 +174,10 @@ TEST(ConversionTestSuite, TestSafeUint8ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToInt8) { +TEST (ConversionTestSuite, TestSafeInt16ToInt8) { RETURN_STATUS Status; - INT16 Operand; - INT8 Result; + INT16 Operand; + INT8 Result; // // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast @@ -205,10 +205,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToChar8) { +TEST (ConversionTestSuite, TestSafeInt16ToChar8) { RETURN_STATUS Status; - INT16 Operand; - CHAR8 Result; + INT16 Operand; + CHAR8 Result; // // CHAR8 is typedefed as char, which may be signed or unsigned based @@ -252,10 +252,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToUint8) { +TEST (ConversionTestSuite, TestSafeInt16ToUint8) { RETURN_STATUS Status; - INT16 Operand; - UINT8 Result; + INT16 Operand; + UINT8 Result; // // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast @@ -278,10 +278,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToUint16) { +TEST (ConversionTestSuite, TestSafeInt16ToUint16) { RETURN_STATUS Status; - INT16 Operand = 0x5b5b; - UINT16 Result = 0; + INT16 Operand = 0x5b5b; + UINT16 Result = 0; // // If Operand is non-negative, then it's a cast @@ -298,10 +298,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToUint32) { +TEST (ConversionTestSuite, TestSafeInt16ToUint32) { RETURN_STATUS Status; - INT16 Operand; - UINT32 Result; + INT16 Operand; + UINT32 Result; // // If Operand is non-negative, then it's a cast @@ -320,10 +320,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToUintn) { +TEST (ConversionTestSuite, TestSafeInt16ToUintn) { RETURN_STATUS Status; - INT16 Operand; - UINTN Result; + INT16 Operand; + UINTN Result; // // If Operand is non-negative, then it's a cast @@ -342,10 +342,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt16ToUint64) { +TEST (ConversionTestSuite, TestSafeInt16ToUint64) { RETURN_STATUS Status; - INT16 Operand; - UINT64 Result; + INT16 Operand; + UINT64 Result; // // If Operand is non-negative, then it's a cast @@ -364,10 +364,10 @@ TEST(ConversionTestSuite, TestSafeInt16ToUint64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint16ToInt8) { +TEST (ConversionTestSuite, TestSafeUint16ToInt8) { RETURN_STATUS Status; - UINT16 Operand; - INT8 Result; + UINT16 Operand; + INT8 Result; // // If Operand is <= MAX_INT8, it's a cast @@ -386,10 +386,10 @@ TEST(ConversionTestSuite, TestSafeUint16ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint16ToChar8) { +TEST (ConversionTestSuite, TestSafeUint16ToChar8) { RETURN_STATUS Status; - UINT16 Operand; - CHAR8 Result; + UINT16 Operand; + CHAR8 Result; // CHAR8 is typedefed as char, which by default is signed, thus // CHAR8 is same as INT8, so same tests as above: @@ -411,10 +411,10 @@ TEST(ConversionTestSuite, TestSafeUint16ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint16ToUint8) { +TEST (ConversionTestSuite, TestSafeUint16ToUint8) { RETURN_STATUS Status; - UINT16 Operand; - UINT8 Result; + UINT16 Operand; + UINT8 Result; // // If Operand is <= MAX_UINT8 (0xff), it's a cast @@ -433,10 +433,10 @@ TEST(ConversionTestSuite, TestSafeUint16ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint16ToInt16) { +TEST (ConversionTestSuite, TestSafeUint16ToInt16) { RETURN_STATUS Status; - UINT16 Operand; - INT16 Result; + UINT16 Operand; + INT16 Result; // // If Operand is <= MAX_INT16 (0x7fff), it's a cast @@ -455,10 +455,10 @@ TEST(ConversionTestSuite, TestSafeUint16ToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToInt8) { +TEST (ConversionTestSuite, TestSafeInt32ToInt8) { RETURN_STATUS Status; - INT32 Operand; - INT8 Result; + INT32 Operand; + INT8 Result; // // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast @@ -486,10 +486,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToChar8) { +TEST (ConversionTestSuite, TestSafeInt32ToChar8) { RETURN_STATUS Status; - INT32 Operand; - CHAR8 Result; + INT32 Operand; + CHAR8 Result; // // CHAR8 is typedefed as char, which may be signed or unsigned based @@ -533,10 +533,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToUint8) { +TEST (ConversionTestSuite, TestSafeInt32ToUint8) { RETURN_STATUS Status; - INT32 Operand; - UINT8 Result; + INT32 Operand; + UINT8 Result; // // If Operand is between 0 and MAX_INT8 inclusive, then it's a cast @@ -563,10 +563,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToInt16) { +TEST (ConversionTestSuite, TestSafeInt32ToInt16) { RETURN_STATUS Status; - INT32 Operand; - INT16 Result; + INT32 Operand; + INT16 Result; // // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast @@ -594,10 +594,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToUint16) { +TEST (ConversionTestSuite, TestSafeInt32ToUint16) { RETURN_STATUS Status; - INT32 Operand; - UINT16 Result; + INT32 Operand; + UINT16 Result; // // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast @@ -624,10 +624,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToUint32) { +TEST (ConversionTestSuite, TestSafeInt32ToUint32) { RETURN_STATUS Status; - INT32 Operand; - UINT32 Result; + INT32 Operand; + UINT32 Result; // // If Operand is non-negative, then it's a cast @@ -646,10 +646,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt32ToUint64) { +TEST (ConversionTestSuite, TestSafeInt32ToUint64) { RETURN_STATUS Status; - INT32 Operand; - UINT64 Result; + INT32 Operand; + UINT64 Result; // // If Operand is non-negative, then it's a cast @@ -668,10 +668,10 @@ TEST(ConversionTestSuite, TestSafeInt32ToUint64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToInt8) { +TEST (ConversionTestSuite, TestSafeUint32ToInt8) { RETURN_STATUS Status; - UINT32 Operand; - INT8 Result; + UINT32 Operand; + INT8 Result; // // If Operand is <= MAX_INT8, then it's a cast @@ -690,10 +690,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToChar8) { +TEST (ConversionTestSuite, TestSafeUint32ToChar8) { RETURN_STATUS Status; - UINT32 Operand; - CHAR8 Result; + UINT32 Operand; + CHAR8 Result; // CHAR8 is typedefed as char, which by default is signed, thus // CHAR8 is same as INT8, so same tests as above: @@ -715,10 +715,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToUint8) { +TEST (ConversionTestSuite, TestSafeUint32ToUint8) { RETURN_STATUS Status; - UINT32 Operand; - UINT8 Result; + UINT32 Operand; + UINT8 Result; // // If Operand is <= MAX_UINT8, then it's a cast @@ -737,10 +737,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToInt16) { +TEST (ConversionTestSuite, TestSafeUint32ToInt16) { RETURN_STATUS Status; - UINT32 Operand; - INT16 Result; + UINT32 Operand; + INT16 Result; // // If Operand is <= MAX_INT16, then it's a cast @@ -759,10 +759,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToUint16) { +TEST (ConversionTestSuite, TestSafeUint32ToUint16) { RETURN_STATUS Status; - UINT32 Operand; - UINT16 Result; + UINT32 Operand; + UINT16 Result; // // If Operand is <= MAX_UINT16, then it's a cast @@ -781,10 +781,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint32ToInt32) { +TEST (ConversionTestSuite, TestSafeUint32ToInt32) { RETURN_STATUS Status; - UINT32 Operand; - INT32 Result; + UINT32 Operand; + INT32 Result; // // If Operand is <= MAX_INT32, then it's a cast @@ -803,10 +803,10 @@ TEST(ConversionTestSuite, TestSafeUint32ToInt32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToInt8) { +TEST (ConversionTestSuite, TestSafeIntnToInt8) { RETURN_STATUS Status; - INTN Operand; - INT8 Result; + INTN Operand; + INT8 Result; // // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast @@ -834,10 +834,10 @@ TEST(ConversionTestSuite, TestSafeIntnToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToChar8) { +TEST (ConversionTestSuite, TestSafeIntnToChar8) { RETURN_STATUS Status; - INTN Operand; - CHAR8 Result; + INTN Operand; + CHAR8 Result; // // CHAR8 is typedefed as char, which may be signed or unsigned based @@ -881,10 +881,10 @@ TEST(ConversionTestSuite, TestSafeIntnToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToUint8) { +TEST (ConversionTestSuite, TestSafeIntnToUint8) { RETURN_STATUS Status; - INTN Operand; - UINT8 Result; + INTN Operand; + UINT8 Result; // // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast @@ -907,10 +907,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToInt16) { +TEST (ConversionTestSuite, TestSafeIntnToInt16) { RETURN_STATUS Status; - INTN Operand; - INT16 Result; + INTN Operand; + INT16 Result; // // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast @@ -938,10 +938,10 @@ TEST(ConversionTestSuite, TestSafeIntnToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToUint16) { +TEST (ConversionTestSuite, TestSafeIntnToUint16) { RETURN_STATUS Status; - INTN Operand; - UINT16 Result; + INTN Operand; + UINT16 Result; // // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast @@ -964,10 +964,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToUintn) { +TEST (ConversionTestSuite, TestSafeIntnToUintn) { RETURN_STATUS Status; - INTN Operand; - UINTN Result; + INTN Operand; + UINTN Result; // // If Operand is non-negative, then it's a cast @@ -986,10 +986,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUintn) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeIntnToUint64) { +TEST (ConversionTestSuite, TestSafeIntnToUint64) { RETURN_STATUS Status; - INTN Operand; - UINT64 Result; + INTN Operand; + UINT64 Result; // // If Operand is non-negative, then it's a cast @@ -1008,10 +1008,10 @@ TEST(ConversionTestSuite, TestSafeIntnToUint64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToInt8) { +TEST (ConversionTestSuite, TestSafeUintnToInt8) { RETURN_STATUS Status; - UINTN Operand; - INT8 Result; + UINTN Operand; + INT8 Result; // // If Operand is <= MAX_INT8, then it's a cast @@ -1030,10 +1030,10 @@ TEST(ConversionTestSuite, TestSafeUintnToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToChar8) { +TEST (ConversionTestSuite, TestSafeUintnToChar8) { RETURN_STATUS Status; - UINTN Operand; - CHAR8 Result; + UINTN Operand; + CHAR8 Result; // CHAR8 is typedefed as char, which by default is signed, thus // CHAR8 is same as INT8, so same tests as above: @@ -1055,10 +1055,10 @@ TEST(ConversionTestSuite, TestSafeUintnToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToUint8) { +TEST (ConversionTestSuite, TestSafeUintnToUint8) { RETURN_STATUS Status; - UINTN Operand; - UINT8 Result; + UINTN Operand; + UINT8 Result; // // If Operand is <= MAX_UINT8, then it's a cast @@ -1077,10 +1077,10 @@ TEST(ConversionTestSuite, TestSafeUintnToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToInt16) { +TEST (ConversionTestSuite, TestSafeUintnToInt16) { RETURN_STATUS Status; - UINTN Operand; - INT16 Result; + UINTN Operand; + INT16 Result; // // If Operand is <= MAX_INT16, then it's a cast @@ -1099,10 +1099,10 @@ TEST(ConversionTestSuite, TestSafeUintnToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToUint16) { +TEST (ConversionTestSuite, TestSafeUintnToUint16) { RETURN_STATUS Status; - UINTN Operand; - UINT16 Result; + UINTN Operand; + UINT16 Result; // // If Operand is <= MAX_UINT16, then it's a cast @@ -1121,10 +1121,10 @@ TEST(ConversionTestSuite, TestSafeUintnToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUintnToInt32) { +TEST (ConversionTestSuite, TestSafeUintnToInt32) { RETURN_STATUS Status; - UINTN Operand; - INT32 Result; + UINTN Operand; + INT32 Result; // // If Operand is <= MAX_INT32, then it's a cast @@ -1143,10 +1143,10 @@ TEST(ConversionTestSuite, TestSafeUintnToInt32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToInt8) { +TEST (ConversionTestSuite, TestSafeInt64ToInt8) { RETURN_STATUS Status; - INT64 Operand; - INT8 Result; + INT64 Operand; + INT8 Result; // // If Operand is between MIN_INT8 and MAX_INT8 inclusive, then it's a cast @@ -1174,10 +1174,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToChar8) { +TEST (ConversionTestSuite, TestSafeInt64ToChar8) { RETURN_STATUS Status; - INT64 Operand; - CHAR8 Result; + INT64 Operand; + CHAR8 Result; // // CHAR8 is typedefed as char, which may be signed or unsigned based @@ -1221,10 +1221,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToUint8) { +TEST (ConversionTestSuite, TestSafeInt64ToUint8) { RETURN_STATUS Status; - INT64 Operand; - UINT8 Result; + INT64 Operand; + UINT8 Result; // // If Operand is between 0 and MAX_UINT8 inclusive, then it's a cast @@ -1247,10 +1247,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToInt16) { +TEST (ConversionTestSuite, TestSafeInt64ToInt16) { RETURN_STATUS Status; - INT64 Operand; - INT16 Result; + INT64 Operand; + INT16 Result; // // If Operand is between MIN_INT16 and MAX_INT16 inclusive, then it's a cast @@ -1278,10 +1278,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToUint16) { +TEST (ConversionTestSuite, TestSafeInt64ToUint16) { RETURN_STATUS Status; - INT64 Operand; - UINT16 Result; + INT64 Operand; + UINT16 Result; // // If Operand is between 0 and MAX_UINT16 inclusive, then it's a cast @@ -1304,10 +1304,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToInt32) { +TEST (ConversionTestSuite, TestSafeInt64ToInt32) { RETURN_STATUS Status; - INT64 Operand; - INT32 Result; + INT64 Operand; + INT32 Result; // // If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast @@ -1335,10 +1335,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToInt32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToUint32) { +TEST (ConversionTestSuite, TestSafeInt64ToUint32) { RETURN_STATUS Status; - INT64 Operand; - UINT32 Result; + INT64 Operand; + UINT32 Result; // // If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast @@ -1361,10 +1361,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeInt64ToUint64) { +TEST (ConversionTestSuite, TestSafeInt64ToUint64) { RETURN_STATUS Status; - INT64 Operand; - UINT64 Result; + INT64 Operand; + UINT64 Result; // // If Operand is non-negative, then it's a cast @@ -1383,10 +1383,10 @@ TEST(ConversionTestSuite, TestSafeInt64ToUint64) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToInt8) { +TEST (ConversionTestSuite, TestSafeUint64ToInt8) { RETURN_STATUS Status; - UINT64 Operand; - INT8 Result; + UINT64 Operand; + INT8 Result; // // If Operand is <= MAX_INT8, then it's a cast @@ -1405,10 +1405,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToInt8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToChar8) { +TEST (ConversionTestSuite, TestSafeUint64ToChar8) { RETURN_STATUS Status; - UINT64 Operand; - CHAR8 Result; + UINT64 Operand; + CHAR8 Result; // CHAR8 is typedefed as char, which by default is signed, thus // CHAR8 is same as INT8, so same tests as above: @@ -1430,10 +1430,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToChar8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToUint8) { +TEST (ConversionTestSuite, TestSafeUint64ToUint8) { RETURN_STATUS Status; - UINT64 Operand; - UINT8 Result; + UINT64 Operand; + UINT8 Result; // // If Operand is <= MAX_UINT8, then it's a cast @@ -1452,10 +1452,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToUint8) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToInt16) { +TEST (ConversionTestSuite, TestSafeUint64ToInt16) { RETURN_STATUS Status; - UINT64 Operand; - INT16 Result; + UINT64 Operand; + INT16 Result; // // If Operand is <= MAX_INT16, then it's a cast @@ -1474,10 +1474,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToInt16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToUint16) { +TEST (ConversionTestSuite, TestSafeUint64ToUint16) { RETURN_STATUS Status; - UINT64 Operand; - UINT16 Result; + UINT64 Operand; + UINT16 Result; // // If Operand is <= MAX_UINT16, then it's a cast @@ -1496,10 +1496,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToUint16) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToInt32) { +TEST (ConversionTestSuite, TestSafeUint64ToInt32) { RETURN_STATUS Status; - UINT64 Operand; - INT32 Result; + UINT64 Operand; + INT32 Result; // // If Operand is <= MAX_INT32, then it's a cast @@ -1518,10 +1518,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToInt32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToUint32) { +TEST (ConversionTestSuite, TestSafeUint64ToUint32) { RETURN_STATUS Status; - UINT64 Operand; - UINT32 Result; + UINT64 Operand; + UINT32 Result; // // If Operand is <= MAX_UINT32, then it's a cast @@ -1540,10 +1540,10 @@ TEST(ConversionTestSuite, TestSafeUint64ToUint32) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(ConversionTestSuite, TestSafeUint64ToInt64) { +TEST (ConversionTestSuite, TestSafeUint64ToInt64) { RETURN_STATUS Status; - UINT64 Operand; - INT64 Result; + UINT64 Operand; + INT64 Result; // // If Operand is <= MAX_INT64, then it's a cast @@ -1565,11 +1565,11 @@ TEST(ConversionTestSuite, TestSafeUint64ToInt64) { // // Addition function tests: // -TEST(AdditionSubtractionTestSuite, TestSafeUint8Add) { +TEST (AdditionSubtractionTestSuite, TestSafeUint8Add) { RETURN_STATUS Status; - UINT8 Augend; - UINT8 Addend; - UINT8 Result; + UINT8 Augend; + UINT8 Addend; + UINT8 Result; // // If the result of addition doesn't overflow MAX_UINT8, then it's addition @@ -1590,11 +1590,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint8Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint16Add) { +TEST (AdditionSubtractionTestSuite, TestSafeUint16Add) { RETURN_STATUS Status; - UINT16 Augend = 0x3a3a; - UINT16 Addend = 0x3a3a; - UINT16 Result = 0; + UINT16 Augend = 0x3a3a; + UINT16 Addend = 0x3a3a; + UINT16 Result = 0; // // If the result of addition doesn't overflow MAX_UINT16, then it's addition @@ -1612,11 +1612,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint16Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint32Add) { +TEST (AdditionSubtractionTestSuite, TestSafeUint32Add) { RETURN_STATUS Status; - UINT32 Augend; - UINT32 Addend; - UINT32 Result; + UINT32 Augend; + UINT32 Addend; + UINT32 Result; // // If the result of addition doesn't overflow MAX_UINT32, then it's addition @@ -1637,11 +1637,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint32Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint64Add) { +TEST (AdditionSubtractionTestSuite, TestSafeUint64Add) { RETURN_STATUS Status; - UINT64 Augend; - UINT64 Addend; - UINT64 Result; + UINT64 Augend; + UINT64 Addend; + UINT64 Result; // // If the result of addition doesn't overflow MAX_UINT64, then it's addition @@ -1662,11 +1662,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint64Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt8Add) { +TEST (AdditionSubtractionTestSuite, TestSafeInt8Add) { RETURN_STATUS Status; - INT8 Augend; - INT8 Addend; - INT8 Result; + INT8 Augend; + INT8 Addend; + INT8 Result; // // If the result of addition doesn't overflow MAX_INT8 @@ -1699,11 +1699,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt8Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt16Add) { +TEST (AdditionSubtractionTestSuite, TestSafeInt16Add) { RETURN_STATUS Status; - INT16 Augend; - INT16 Addend; - INT16 Result; + INT16 Augend; + INT16 Addend; + INT16 Result; // // If the result of addition doesn't overflow MAX_INT16 @@ -1736,11 +1736,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt16Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt32Add) { +TEST (AdditionSubtractionTestSuite, TestSafeInt32Add) { RETURN_STATUS Status; - INT32 Augend; - INT32 Addend; - INT32 Result; + INT32 Augend; + INT32 Addend; + INT32 Result; // // If the result of addition doesn't overflow MAX_INT32 @@ -1773,11 +1773,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt32Add) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt64Add) { +TEST (AdditionSubtractionTestSuite, TestSafeInt64Add) { RETURN_STATUS Status; - INT64 Augend; - INT64 Addend; - INT64 Result; + INT64 Augend; + INT64 Addend; + INT64 Result; // // If the result of addition doesn't overflow MAX_INT64 @@ -1813,11 +1813,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt64Add) { // // Subtraction function tests: // -TEST(AdditionSubtractionTestSuite, TestSafeUint8Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeUint8Sub) { RETURN_STATUS Status; - UINT8 Minuend; - UINT8 Subtrahend; - UINT8 Result; + UINT8 Minuend; + UINT8 Subtrahend; + UINT8 Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -1838,11 +1838,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint8Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint16Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeUint16Sub) { RETURN_STATUS Status; - UINT16 Minuend; - UINT16 Subtrahend; - UINT16 Result; + UINT16 Minuend; + UINT16 Subtrahend; + UINT16 Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -1863,11 +1863,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint16Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint32Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeUint32Sub) { RETURN_STATUS Status; - UINT32 Minuend; - UINT32 Subtrahend; - UINT32 Result; + UINT32 Minuend; + UINT32 Subtrahend; + UINT32 Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -1888,11 +1888,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint32Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeUint64Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeUint64Sub) { RETURN_STATUS Status; - UINT64 Minuend; - UINT64 Subtrahend; - UINT64 Result; + UINT64 Minuend; + UINT64 Subtrahend; + UINT64 Result; // // If Minuend >= Subtrahend, then it's subtraction @@ -1913,11 +1913,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeUint64Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt8Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeInt8Sub) { RETURN_STATUS Status; - INT8 Minuend; - INT8 Subtrahend; - INT8 Result; + INT8 Minuend; + INT8 Subtrahend; + INT8 Result; // // If the result of subtractions doesn't overflow MAX_INT8 or @@ -1950,11 +1950,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt8Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt16Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeInt16Sub) { RETURN_STATUS Status; - INT16 Minuend; - INT16 Subtrahend; - INT16 Result; + INT16 Minuend; + INT16 Subtrahend; + INT16 Result; // // If the result of subtractions doesn't overflow MAX_INT16 or @@ -1987,11 +1987,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt16Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt32Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeInt32Sub) { RETURN_STATUS Status; - INT32 Minuend; - INT32 Subtrahend; - INT32 Result; + INT32 Minuend; + INT32 Subtrahend; + INT32 Result; // // If the result of subtractions doesn't overflow MAX_INT32 or @@ -2024,11 +2024,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt32Sub) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(AdditionSubtractionTestSuite, TestSafeInt64Sub) { +TEST (AdditionSubtractionTestSuite, TestSafeInt64Sub) { RETURN_STATUS Status; - INT64 Minuend; - INT64 Subtrahend; - INT64 Result; + INT64 Minuend; + INT64 Subtrahend; + INT64 Result; // // If the result of subtractions doesn't overflow MAX_INT64 or @@ -2064,11 +2064,11 @@ TEST(AdditionSubtractionTestSuite, TestSafeInt64Sub) { // // Multiplication function tests: // -TEST(MultiplicationTestSuite, TestSafeUint8Mult) { +TEST (MultiplicationTestSuite, TestSafeUint8Mult) { RETURN_STATUS Status; - UINT8 Multiplicand; - UINT8 Multiplier; - UINT8 Result; + UINT8 Multiplicand; + UINT8 Multiplier; + UINT8 Result; // // If the result of multiplication doesn't overflow MAX_UINT8, it will succeed @@ -2089,11 +2089,11 @@ TEST(MultiplicationTestSuite, TestSafeUint8Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeUint16Mult) { +TEST (MultiplicationTestSuite, TestSafeUint16Mult) { RETURN_STATUS Status; - UINT16 Multiplicand; - UINT16 Multiplier; - UINT16 Result; + UINT16 Multiplicand; + UINT16 Multiplier; + UINT16 Result; // // If the result of multiplication doesn't overflow MAX_UINT16, it will succeed @@ -2114,11 +2114,11 @@ TEST(MultiplicationTestSuite, TestSafeUint16Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeUint32Mult) { +TEST (MultiplicationTestSuite, TestSafeUint32Mult) { RETURN_STATUS Status; - UINT32 Multiplicand; - UINT32 Multiplier; - UINT32 Result; + UINT32 Multiplicand; + UINT32 Multiplier; + UINT32 Result; // // If the result of multiplication doesn't overflow MAX_UINT32, it will succeed @@ -2139,11 +2139,11 @@ TEST(MultiplicationTestSuite, TestSafeUint32Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeUint64Mult) { +TEST (MultiplicationTestSuite, TestSafeUint64Mult) { RETURN_STATUS Status; - UINT64 Multiplicand; - UINT64 Multiplier; - UINT64 Result; + UINT64 Multiplicand; + UINT64 Multiplier; + UINT64 Result; // // If the result of multiplication doesn't overflow MAX_UINT64, it will succeed @@ -2164,11 +2164,11 @@ TEST(MultiplicationTestSuite, TestSafeUint64Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeInt8Mult) { +TEST (MultiplicationTestSuite, TestSafeInt8Mult) { RETURN_STATUS Status; - INT8 Multiplicand; - INT8 Multiplier; - INT8 Result; + INT8 Multiplicand; + INT8 Multiplier; + INT8 Result; // // If the result of multiplication doesn't overflow MAX_INT8 and doesn't @@ -2190,11 +2190,11 @@ TEST(MultiplicationTestSuite, TestSafeInt8Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeInt16Mult) { +TEST (MultiplicationTestSuite, TestSafeInt16Mult) { RETURN_STATUS Status; - INT16 Multiplicand; - INT16 Multiplier; - INT16 Result; + INT16 Multiplicand; + INT16 Multiplier; + INT16 Result; // // If the result of multiplication doesn't overflow MAX_INT16 and doesn't @@ -2216,11 +2216,11 @@ TEST(MultiplicationTestSuite, TestSafeInt16Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeInt32Mult) { +TEST (MultiplicationTestSuite, TestSafeInt32Mult) { RETURN_STATUS Status; - INT32 Multiplicand; - INT32 Multiplier; - INT32 Result; + INT32 Multiplicand; + INT32 Multiplier; + INT32 Result; // // If the result of multiplication doesn't overflow MAX_INT32 and doesn't @@ -2242,11 +2242,11 @@ TEST(MultiplicationTestSuite, TestSafeInt32Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -TEST(MultiplicationTestSuite, TestSafeInt64Mult) { +TEST (MultiplicationTestSuite, TestSafeInt64Mult) { RETURN_STATUS Status; - INT64 Multiplicand; - INT64 Multiplier; - INT64 Result; + INT64 Multiplicand; + INT64 Multiplier; + INT64 Result; // // If the result of multiplication doesn't overflow MAX_INT64 and doesn't @@ -2268,7 +2268,12 @@ TEST(MultiplicationTestSuite, TestSafeInt64Mult) { ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status); } -int main(int argc, char* argv[]) { - testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); +int +main ( + int argc, + char *argv[] + ) +{ + testing::InitGoogleTest (&argc, argv); + return RUN_ALL_TESTS (); } diff --git a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockHobLib.h b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockHobLib.h index 994b8133e5..586b479ea5 100644 --- a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockHobLib.h +++ b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockHobLib.h @@ -11,9 +11,9 @@ #include #include extern "C" { -#include -#include -#include + #include + #include + #include } struct MockHobLib { diff --git a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockPeiServicesLib.h b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockPeiServicesLib.h index 4a99fec539..6a6424d7c6 100644 --- a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockPeiServicesLib.h +++ b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockPeiServicesLib.h @@ -11,9 +11,9 @@ #include #include extern "C" { -#include -#include -#include + #include + #include + #include } struct MockPeiServicesLib { diff --git a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiLib.h b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiLib.h index dec2c93e1b..93697da9cf 100644 --- a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiLib.h +++ b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiLib.h @@ -11,8 +11,8 @@ #include #include extern "C" { -#include -#include + #include + #include } struct MockUefiLib { diff --git a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiRuntimeServicesTableLib.h b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiRuntimeServicesTableLib.h index afdfc6b855..241abc55c0 100644 --- a/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiRuntimeServicesTableLib.h +++ b/MdePkg/Test/Mock/Include/GoogleTest/Library/MockUefiRuntimeServicesTableLib.h @@ -11,8 +11,8 @@ #include #include extern "C" { -#include -#include + #include + #include } struct MockUefiRuntimeServicesTableLib { diff --git a/MdePkg/Test/Mock/Library/GoogleTest/MockHobLib/MockHobLib.cpp b/MdePkg/Test/Mock/Library/GoogleTest/MockHobLib/MockHobLib.cpp index 5a5a9159fc..51ee09065e 100644 --- a/MdePkg/Test/Mock/Library/GoogleTest/MockHobLib/MockHobLib.cpp +++ b/MdePkg/Test/Mock/Library/GoogleTest/MockHobLib/MockHobLib.cpp @@ -7,24 +7,24 @@ #include -MOCK_INTERFACE_DEFINITION(MockHobLib); +MOCK_INTERFACE_DEFINITION (MockHobLib); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetHobList, 0, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetNextHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetFirstHob, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetNextGuidHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetFirstGuidHob, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, GetBootModeHob, 0, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildModuleHob, 4, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildResourceDescriptorWithOwnerHob, 5, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildResourceDescriptorHob, 4, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildGuidHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildGuidDataHob, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildFvHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildFv2Hob, 4, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildFv3Hob, 6, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildCvHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildCpuHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildStackHob, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildBspStoreHob, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockHobLib, BuildMemoryAllocationHob, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetHobList, 0, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetNextHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetFirstHob, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetNextGuidHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetFirstGuidHob, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, GetBootModeHob, 0, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildModuleHob, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildResourceDescriptorWithOwnerHob, 5, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildResourceDescriptorHob, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildGuidHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildGuidDataHob, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildFvHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildFv2Hob, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildFv3Hob, 6, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildCvHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildCpuHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildStackHob, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildBspStoreHob, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockHobLib, BuildMemoryAllocationHob, 3, EFIAPI); diff --git a/MdePkg/Test/Mock/Library/GoogleTest/MockPeiServicesLib/MockPeiServicesLib.cpp b/MdePkg/Test/Mock/Library/GoogleTest/MockPeiServicesLib/MockPeiServicesLib.cpp index 9a7ff4bd8f..c6035bd664 100644 --- a/MdePkg/Test/Mock/Library/GoogleTest/MockPeiServicesLib/MockPeiServicesLib.cpp +++ b/MdePkg/Test/Mock/Library/GoogleTest/MockPeiServicesLib/MockPeiServicesLib.cpp @@ -7,30 +7,30 @@ #include -MOCK_INTERFACE_DEFINITION(MockPeiServicesLib); +MOCK_INTERFACE_DEFINITION (MockPeiServicesLib); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesInstallPpi, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesReInstallPpi, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesLocatePpi, 4, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesNotifyPpi, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesGetBootMode, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesSetBootMode, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesGetHobList, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesCreateHob, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsFindNextVolume, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsFindNextFile, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsFindSectionData, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsFindSectionData3, 5, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesInstallPeiMemory, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesAllocatePages, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFreePages, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesAllocatePool, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesResetSystem, 0, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsFindFileByName, 3, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsGetFileInfo, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsGetFileInfo2, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesFfsGetVolumeInfo, 2, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesRegisterForShadow, 1, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesInstallFvInfoPpi, 5, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesInstallFvInfo2Ppi, 6, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockPeiServicesLib, PeiServicesResetSystem2, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesInstallPpi, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesReInstallPpi, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesLocatePpi, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesNotifyPpi, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesGetBootMode, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesSetBootMode, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesGetHobList, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesCreateHob, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsFindNextVolume, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsFindNextFile, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsFindSectionData, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsFindSectionData3, 5, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesInstallPeiMemory, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesAllocatePages, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFreePages, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesAllocatePool, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesResetSystem, 0, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsFindFileByName, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsGetFileInfo, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsGetFileInfo2, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesFfsGetVolumeInfo, 2, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesRegisterForShadow, 1, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesInstallFvInfoPpi, 5, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesInstallFvInfo2Ppi, 6, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockPeiServicesLib, PeiServicesResetSystem2, 4, EFIAPI); diff --git a/MdePkg/Test/Mock/Library/GoogleTest/MockUefiLib/MockUefiLib.cpp b/MdePkg/Test/Mock/Library/GoogleTest/MockUefiLib/MockUefiLib.cpp index 5339d040c9..2a0c9613ea 100644 --- a/MdePkg/Test/Mock/Library/GoogleTest/MockUefiLib/MockUefiLib.cpp +++ b/MdePkg/Test/Mock/Library/GoogleTest/MockUefiLib/MockUefiLib.cpp @@ -6,7 +6,7 @@ **/ #include -MOCK_INTERFACE_DEFINITION(MockUefiLib); +MOCK_INTERFACE_DEFINITION (MockUefiLib); -MOCK_FUNCTION_DEFINITION(MockUefiLib, GetVariable2, 4, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockUefiLib, GetEfiGlobalVariable2, 3, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockUefiLib, GetVariable2, 4, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockUefiLib, GetEfiGlobalVariable2, 3, EFIAPI); diff --git a/MdePkg/Test/Mock/Library/GoogleTest/MockUefiRuntimeServicesTableLib/MockUefiRuntimeServicesTableLib.cpp b/MdePkg/Test/Mock/Library/GoogleTest/MockUefiRuntimeServicesTableLib/MockUefiRuntimeServicesTableLib.cpp index ecd1ba8236..14296b0ccb 100644 --- a/MdePkg/Test/Mock/Library/GoogleTest/MockUefiRuntimeServicesTableLib/MockUefiRuntimeServicesTableLib.cpp +++ b/MdePkg/Test/Mock/Library/GoogleTest/MockUefiRuntimeServicesTableLib/MockUefiRuntimeServicesTableLib.cpp @@ -6,13 +6,13 @@ **/ #include -MOCK_INTERFACE_DEFINITION(MockUefiRuntimeServicesTableLib); +MOCK_INTERFACE_DEFINITION (MockUefiRuntimeServicesTableLib); -MOCK_FUNCTION_DEFINITION(MockUefiRuntimeServicesTableLib, gRT_GetVariable, 5, EFIAPI); -MOCK_FUNCTION_DEFINITION(MockUefiRuntimeServicesTableLib, gRT_SetVariable, 5, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockUefiRuntimeServicesTableLib, gRT_GetVariable, 5, EFIAPI); +MOCK_FUNCTION_DEFINITION (MockUefiRuntimeServicesTableLib, gRT_SetVariable, 5, EFIAPI); -static EFI_RUNTIME_SERVICES localRt = { - {0}, // EFI_TABLE_HEADER +static EFI_RUNTIME_SERVICES localRt = { + { 0 }, // EFI_TABLE_HEADER NULL, // EFI_GET_TIME NULL, // EFI_SET_TIME @@ -36,5 +36,5 @@ static EFI_RUNTIME_SERVICES localRt = { }; extern "C" { - EFI_RUNTIME_SERVICES* gRT = &localRt; + EFI_RUNTIME_SERVICES *gRT = &localRt; }