[mirror_edk2.git] / MdePkg / Test / UnitTest / Library / BaseSafeIntLib / SafeIntLibUintnIntnUnitTests64.c

/** @file\r
  x64-specific functions for unit-testing INTN and UINTN functions in\r
  SafeIntLib.\r
\r
  Copyright (c) Microsoft Corporation.<BR>\r
  Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>\r
  SPDX-License-Identifier: BSD-2-Clause-Patent\r
\r
**/\r
\r
#include "TestBaseSafeIntLib.h"\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeInt32ToUintn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INT32       Operand;\r
  UINTN       Result;\r
\r
  //\r
  // If Operand is non-negative, then it's a cast\r
  //\r
  Operand = 0x5bababab;\r
  Result  = 0;\r
  Status  = SafeInt32ToUintn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5bababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (-1537977259);\r
  Status  = SafeInt32ToUintn (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUint32ToIntn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT32      Operand;\r
  INTN        Result;\r
\r
  //\r
  // For x64, INTN is same as INT64 which is a superset of INT32\r
  // This is just a cast then, and it'll never fail\r
  //\r
\r
  //\r
  // If Operand is non-negative, then it's a cast\r
  //\r
  Operand = 0xabababab;\r
  Result  = 0;\r
  Status  = SafeUint32ToIntn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0xabababab, Result);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeIntnToInt32 (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INTN        Operand;\r
  INT32       Result;\r
\r
  //\r
  // If Operand is between MIN_INT32 and  MAX_INT32 inclusive, then it's a cast\r
  //\r
  Operand = 0x5bababab;\r
  Result  = 0;\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5bababab, Result);\r
\r
  Operand = (-1537977259);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL ((-1537977259), Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0x5babababefefefef);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeIntnToUint32 (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INTN        Operand;\r
  UINT32      Result;\r
\r
  //\r
  // If Operand is between 0 and  MAX_UINT32 inclusive, then it's a cast\r
  //\r
  Operand = 0xabababab;\r
  Result  = 0;\r
  Status  = SafeIntnToUint32 (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0xabababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0x5babababefefefef);\r
  Status  = SafeIntnToUint32 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeIntnToUint32 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnToUint32 (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Operand;\r
  UINT32      Result;\r
\r
  //\r
  // If Operand is <= MAX_UINT32, then it's a cast\r
  //\r
  Operand = 0xabababab;\r
  Result  = 0;\r
  Status  = SafeUintnToUint32 (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0xabababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToUint32 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnToIntn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Operand;\r
  INTN        Result;\r
\r
  //\r
  // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
  //\r
  Operand = 0x5babababefefefef;\r
  Result  = 0;\r
  Status  = SafeUintnToIntn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToIntn (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnToInt64 (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Operand;\r
  INT64       Result;\r
\r
  //\r
  // If Operand is <= MAX_INT64, then it's a cast\r
  //\r
  Operand = 0x5babababefefefef;\r
  Result  = 0;\r
  Status  = SafeUintnToInt64 (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToInt64 (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeInt64ToIntn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INT64       Operand;\r
  INTN        Result;\r
\r
  //\r
  // INTN is same as INT64 in x64, so this is just a cast\r
  //\r
  Operand = 0x5babababefefefef;\r
  Result  = 0;\r
  Status  = SafeInt64ToIntn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeInt64ToUintn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INT64       Operand;\r
  UINTN       Result;\r
\r
  //\r
  // If Operand is non-negative, then it's a cast\r
  //\r
  Operand = 0x5babababefefefef;\r
  Result  = 0;\r
  Status  = SafeInt64ToUintn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeInt64ToUintn (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUint64ToIntn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT64      Operand;\r
  INTN        Result;\r
\r
  //\r
  // If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
  //\r
  Operand = 0x5babababefefefef;\r
  Result  = 0;\r
  Status  = SafeUint64ToIntn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUint64ToIntn (Operand, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUint64ToUintn (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINT64      Operand;\r
  UINTN       Result;\r
\r
  //\r
  // UINTN is same as UINT64 in x64, so this is just a cast\r
  //\r
  Operand = 0xababababefefefef;\r
  Result  = 0;\r
  Status  = SafeUint64ToUintn (Operand, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0xababababefefefef, Result);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnAdd (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Augend;\r
  UINTN       Addend;\r
  UINTN       Result;\r
\r
  //\r
  // If the result of addition doesn't overflow MAX_UINTN, then it's addition\r
  //\r
  Augend = 0x3a3a3a3a12121212;\r
  Addend = 0x3a3a3a3a12121212;\r
  Result = 0;\r
  Status = SafeUintnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x7474747424242424, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Augend = 0xababababefefefef;\r
  Addend = 0xbcbcbcbcdededede;\r
  Status = SafeUintnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeIntnAdd (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INTN        Augend;\r
  INTN        Addend;\r
  INTN        Result;\r
\r
  //\r
  // If the result of addition doesn't overflow MAX_INTN\r
  // and doesn't underflow MIN_INTN, then it's addition\r
  //\r
  Augend = 0x3a3a3a3a3a3a3a3a;\r
  Addend = 0x3a3a3a3a3a3a3a3a;\r
  Result = 0;\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x7474747474747474, Result);\r
\r
  Augend = (-4195730024608447034);\r
  Addend = (-4195730024608447034);\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL ((-8391460049216894068), Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Augend = 0x5a5a5a5a5a5a5a5a;\r
  Addend = 0x5a5a5a5a5a5a5a5a;\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Augend = (-6510615555426900570);\r
  Addend = (-6510615555426900570);\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnSub (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Minuend;\r
  UINTN       Subtrahend;\r
  UINTN       Result;\r
\r
  //\r
  // If Minuend >= Subtrahend, then it's subtraction\r
  //\r
  Minuend    = 0x5a5a5a5a5a5a5a5a;\r
  Subtrahend = 0x3b3b3b3b3b3b3b3b;\r
  Result     = 0;\r
  Status     = SafeUintnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x1f1f1f1f1f1f1f1f, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Minuend    = 0x5a5a5a5a5a5a5a5a;\r
  Subtrahend = 0x6d6d6d6d6d6d6d6d;\r
  Status     = SafeUintnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeIntnSub (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INTN        Minuend;\r
  INTN        Subtrahend;\r
  INTN        Result;\r
\r
  //\r
  // If the result of subtractions doesn't overflow MAX_INTN or\r
  // underflow MIN_INTN, then it's subtraction\r
  //\r
  Minuend    = 0x5a5a5a5a5a5a5a5a;\r
  Subtrahend = 0x3a3a3a3a3a3a3a3a;\r
  Result     = 0;\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x2020202020202020, Result);\r
\r
  Minuend    = 0x3a3a3a3a3a3a3a3a;\r
  Subtrahend = 0x5a5a5a5a5a5a5a5a;\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL ((-2314885530818453536), Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Minuend    = (-8825501086245354106);\r
  Subtrahend = 8825501086245354106;\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Minuend    = (8825501086245354106);\r
  Subtrahend = (-8825501086245354106);\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeUintnMult (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  UINTN       Multiplicand;\r
  UINTN       Multiplier;\r
  UINTN       Result;\r
\r
  //\r
  // If the result of multiplication doesn't overflow MAX_UINTN, it will succeed\r
  //\r
  Multiplicand = 0x123456789a;\r
  Multiplier   = 0x1234567;\r
  Result       = 0;\r
  Status       = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x14b66db9745a07f6, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Multiplicand = 0x123456789a;\r
  Multiplier   = 0x12345678;\r
  Status       = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
\r
UNIT_TEST_STATUS\r
EFIAPI\r
TestSafeIntnMult (\r
  IN UNIT_TEST_CONTEXT  Context\r
  )\r
{\r
  EFI_STATUS  Status;\r
  INTN        Multiplicand;\r
  INTN        Multiplier;\r
  INTN        Result;\r
\r
  //\r
  // If the result of multiplication doesn't overflow MAX_INTN and doesn't\r
  // underflow MIN_UINTN, it will succeed\r
  //\r
  Multiplicand = 0x123456789;\r
  Multiplier   = 0x6789abcd;\r
  Result       = 0;\r
  Status       = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
  UT_ASSERT_NOT_EFI_ERROR (Status);\r
  UT_ASSERT_EQUAL (0x75cd9045220d6bb5, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Multiplicand = 0x123456789;\r
  Multiplier   = 0xa789abcd;\r
  Status       = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
  UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  return UNIT_TEST_PASSED;\r
}\r
Commit	Line	Data
e50c2bb3 MK	1	/** @file\r
	2	x64-specific functions for unit-testing INTN and UINTN functions in\r
	3	SafeIntLib.\r
	4	\r
	5	Copyright (c) Microsoft Corporation.<BR>\r
	6	Copyright (c) 2019 - 2020, Intel Corporation. All rights reserved.<BR>\r
	7	SPDX-License-Identifier: BSD-2-Clause-Patent\r
	8	\r
	9	**/\r
	10	\r
	11	#include "TestBaseSafeIntLib.h"\r
	12	\r
	13	UNIT_TEST_STATUS\r
	14	EFIAPI\r
	15	TestSafeInt32ToUintn (\r
2f88bd3a	16	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	17	)\r
	18	{\r
	19	EFI_STATUS Status;\r
	20	INT32 Operand;\r
	21	UINTN Result;\r
	22	\r
	23	//\r
	24	// If Operand is non-negative, then it's a cast\r
	25	//\r
	26	Operand = 0x5bababab;\r
2f88bd3a MK	27	Result = 0;\r
	28	Status = SafeInt32ToUintn (Operand, &Result);\r
	29	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	30	UT_ASSERT_EQUAL (0x5bababab, Result);\r
e50c2bb3 MK	31	\r
	32	//\r
	33	// Otherwise should result in an error status\r
	34	//\r
	35	Operand = (-1537977259);\r
2f88bd3a MK	36	Status = SafeInt32ToUintn (Operand, &Result);\r
2f88bd3a MK	37	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	38	\r
	39	return UNIT_TEST_PASSED;\r
	40	}\r
	41	\r
	42	UNIT_TEST_STATUS\r
	43	EFIAPI\r
	44	TestSafeUint32ToIntn (\r
2f88bd3a	45	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	46	)\r
	47	{\r
	48	EFI_STATUS Status;\r
	49	UINT32 Operand;\r
	50	INTN Result;\r
	51	\r
	52	//\r
	53	// For x64, INTN is same as INT64 which is a superset of INT32\r
	54	// This is just a cast then, and it'll never fail\r
	55	//\r
	56	\r
	57	//\r
	58	// If Operand is non-negative, then it's a cast\r
	59	//\r
	60	Operand = 0xabababab;\r
2f88bd3a MK	61	Result = 0;\r
	62	Status = SafeUint32ToIntn (Operand, &Result);\r
	63	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	64	UT_ASSERT_EQUAL (0xabababab, Result);\r
e50c2bb3 MK	65	\r
	66	return UNIT_TEST_PASSED;\r
	67	}\r
	68	\r
	69	UNIT_TEST_STATUS\r
	70	EFIAPI\r
	71	TestSafeIntnToInt32 (\r
2f88bd3a	72	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	73	)\r
	74	{\r
	75	EFI_STATUS Status;\r
	76	INTN Operand;\r
	77	INT32 Result;\r
	78	\r
	79	//\r
	80	// If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast\r
	81	//\r
	82	Operand = 0x5bababab;\r
2f88bd3a MK	83	Result = 0;\r
	84	Status = SafeIntnToInt32 (Operand, &Result);\r
	85	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	86	UT_ASSERT_EQUAL (0x5bababab, Result);\r
e50c2bb3 MK	87	\r
e50c2bb3 MK	88	Operand = (-1537977259);\r
2f88bd3a MK	89	Status = SafeIntnToInt32 (Operand, &Result);\r
	90	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	91	UT_ASSERT_EQUAL ((-1537977259), Result);\r
e50c2bb3 MK	92	\r
	93	//\r
	94	// Otherwise should result in an error status\r
	95	//\r
	96	Operand = (0x5babababefefefef);\r
2f88bd3a MK	97	Status = SafeIntnToInt32 (Operand, &Result);\r
2f88bd3a MK	98	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	99	\r
e50c2bb3 MK	100	Operand = (-6605562033422200815);\r
2f88bd3a MK	101	Status = SafeIntnToInt32 (Operand, &Result);\r
2f88bd3a MK	102	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	103	\r
	104	return UNIT_TEST_PASSED;\r
	105	}\r
	106	\r
	107	UNIT_TEST_STATUS\r
	108	EFIAPI\r
	109	TestSafeIntnToUint32 (\r
2f88bd3a	110	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	111	)\r
	112	{\r
	113	EFI_STATUS Status;\r
	114	INTN Operand;\r
	115	UINT32 Result;\r
	116	\r
	117	//\r
	118	// If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast\r
	119	//\r
	120	Operand = 0xabababab;\r
2f88bd3a MK	121	Result = 0;\r
	122	Status = SafeIntnToUint32 (Operand, &Result);\r
	123	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	124	UT_ASSERT_EQUAL (0xabababab, Result);\r
e50c2bb3 MK	125	\r
	126	//\r
	127	// Otherwise should result in an error status\r
	128	//\r
	129	Operand = (0x5babababefefefef);\r
2f88bd3a MK	130	Status = SafeIntnToUint32 (Operand, &Result);\r
2f88bd3a MK	131	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	132	\r
e50c2bb3 MK	133	Operand = (-6605562033422200815);\r
2f88bd3a MK	134	Status = SafeIntnToUint32 (Operand, &Result);\r
2f88bd3a MK	135	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	136	\r
	137	return UNIT_TEST_PASSED;\r
	138	}\r
	139	\r
	140	UNIT_TEST_STATUS\r
	141	EFIAPI\r
	142	TestSafeUintnToUint32 (\r
2f88bd3a	143	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	144	)\r
	145	{\r
	146	EFI_STATUS Status;\r
	147	UINTN Operand;\r
	148	UINT32 Result;\r
	149	\r
	150	//\r
	151	// If Operand is <= MAX_UINT32, then it's a cast\r
	152	//\r
	153	Operand = 0xabababab;\r
2f88bd3a MK	154	Result = 0;\r
	155	Status = SafeUintnToUint32 (Operand, &Result);\r
	156	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	157	UT_ASSERT_EQUAL (0xabababab, Result);\r
e50c2bb3 MK	158	\r
	159	//\r
	160	// Otherwise should result in an error status\r
	161	//\r
	162	Operand = (0xababababefefefef);\r
2f88bd3a MK	163	Status = SafeUintnToUint32 (Operand, &Result);\r
2f88bd3a MK	164	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	165	\r
	166	return UNIT_TEST_PASSED;\r
	167	}\r
	168	\r
	169	UNIT_TEST_STATUS\r
	170	EFIAPI\r
	171	TestSafeUintnToIntn (\r
2f88bd3a	172	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	173	)\r
	174	{\r
	175	EFI_STATUS Status;\r
	176	UINTN Operand;\r
	177	INTN Result;\r
	178	\r
	179	//\r
	180	// If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
	181	//\r
	182	Operand = 0x5babababefefefef;\r
2f88bd3a MK	183	Result = 0;\r
	184	Status = SafeUintnToIntn (Operand, &Result);\r
	185	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	186	UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
e50c2bb3 MK	187	\r
	188	//\r
	189	// Otherwise should result in an error status\r
	190	//\r
	191	Operand = (0xababababefefefef);\r
2f88bd3a MK	192	Status = SafeUintnToIntn (Operand, &Result);\r
2f88bd3a MK	193	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	194	\r
	195	return UNIT_TEST_PASSED;\r
	196	}\r
	197	\r
	198	UNIT_TEST_STATUS\r
	199	EFIAPI\r
	200	TestSafeUintnToInt64 (\r
2f88bd3a	201	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	202	)\r
	203	{\r
	204	EFI_STATUS Status;\r
	205	UINTN Operand;\r
	206	INT64 Result;\r
	207	\r
	208	//\r
	209	// If Operand is <= MAX_INT64, then it's a cast\r
	210	//\r
	211	Operand = 0x5babababefefefef;\r
2f88bd3a MK	212	Result = 0;\r
	213	Status = SafeUintnToInt64 (Operand, &Result);\r
	214	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	215	UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
e50c2bb3 MK	216	\r
	217	//\r
	218	// Otherwise should result in an error status\r
	219	//\r
	220	Operand = (0xababababefefefef);\r
2f88bd3a MK	221	Status = SafeUintnToInt64 (Operand, &Result);\r
2f88bd3a MK	222	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	223	\r
	224	return UNIT_TEST_PASSED;\r
	225	}\r
	226	\r
	227	UNIT_TEST_STATUS\r
	228	EFIAPI\r
	229	TestSafeInt64ToIntn (\r
2f88bd3a	230	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	231	)\r
	232	{\r
	233	EFI_STATUS Status;\r
	234	INT64 Operand;\r
	235	INTN Result;\r
	236	\r
	237	//\r
	238	// INTN is same as INT64 in x64, so this is just a cast\r
	239	//\r
	240	Operand = 0x5babababefefefef;\r
2f88bd3a MK	241	Result = 0;\r
	242	Status = SafeInt64ToIntn (Operand, &Result);\r
	243	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	244	UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
e50c2bb3 MK	245	\r
	246	return UNIT_TEST_PASSED;\r
	247	}\r
	248	\r
	249	UNIT_TEST_STATUS\r
	250	EFIAPI\r
	251	TestSafeInt64ToUintn (\r
2f88bd3a	252	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	253	)\r
	254	{\r
	255	EFI_STATUS Status;\r
	256	INT64 Operand;\r
	257	UINTN Result;\r
	258	\r
	259	//\r
	260	// If Operand is non-negative, then it's a cast\r
	261	//\r
	262	Operand = 0x5babababefefefef;\r
2f88bd3a MK	263	Result = 0;\r
	264	Status = SafeInt64ToUintn (Operand, &Result);\r
	265	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	266	UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
e50c2bb3 MK	267	\r
	268	//\r
	269	// Otherwise should result in an error status\r
	270	//\r
	271	Operand = (-6605562033422200815);\r
2f88bd3a MK	272	Status = SafeInt64ToUintn (Operand, &Result);\r
2f88bd3a MK	273	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	274	\r
	275	return UNIT_TEST_PASSED;\r
	276	}\r
	277	\r
	278	UNIT_TEST_STATUS\r
	279	EFIAPI\r
	280	TestSafeUint64ToIntn (\r
2f88bd3a	281	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	282	)\r
	283	{\r
	284	EFI_STATUS Status;\r
	285	UINT64 Operand;\r
	286	INTN Result;\r
	287	\r
	288	//\r
	289	// If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
	290	//\r
	291	Operand = 0x5babababefefefef;\r
2f88bd3a MK	292	Result = 0;\r
	293	Status = SafeUint64ToIntn (Operand, &Result);\r
	294	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	295	UT_ASSERT_EQUAL (0x5babababefefefef, Result);\r
e50c2bb3 MK	296	\r
	297	//\r
	298	// Otherwise should result in an error status\r
	299	//\r
	300	Operand = (0xababababefefefef);\r
2f88bd3a MK	301	Status = SafeUint64ToIntn (Operand, &Result);\r
2f88bd3a MK	302	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	303	\r
	304	return UNIT_TEST_PASSED;\r
	305	}\r
	306	\r
	307	UNIT_TEST_STATUS\r
	308	EFIAPI\r
	309	TestSafeUint64ToUintn (\r
2f88bd3a	310	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	311	)\r
	312	{\r
	313	EFI_STATUS Status;\r
	314	UINT64 Operand;\r
	315	UINTN Result;\r
	316	\r
	317	//\r
	318	// UINTN is same as UINT64 in x64, so this is just a cast\r
	319	//\r
	320	Operand = 0xababababefefefef;\r
2f88bd3a MK	321	Result = 0;\r
	322	Status = SafeUint64ToUintn (Operand, &Result);\r
	323	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	324	UT_ASSERT_EQUAL (0xababababefefefef, Result);\r
e50c2bb3 MK	325	\r
	326	return UNIT_TEST_PASSED;\r
	327	}\r
	328	\r
	329	UNIT_TEST_STATUS\r
	330	EFIAPI\r
	331	TestSafeUintnAdd (\r
2f88bd3a	332	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	333	)\r
	334	{\r
	335	EFI_STATUS Status;\r
	336	UINTN Augend;\r
	337	UINTN Addend;\r
	338	UINTN Result;\r
	339	\r
	340	//\r
	341	// If the result of addition doesn't overflow MAX_UINTN, then it's addition\r
	342	//\r
	343	Augend = 0x3a3a3a3a12121212;\r
	344	Addend = 0x3a3a3a3a12121212;\r
	345	Result = 0;\r
2f88bd3a MK	346	Status = SafeUintnAdd (Augend, Addend, &Result);\r
	347	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	348	UT_ASSERT_EQUAL (0x7474747424242424, Result);\r
e50c2bb3 MK	349	\r
	350	//\r
	351	// Otherwise should result in an error status\r
	352	//\r
	353	Augend = 0xababababefefefef;\r
	354	Addend = 0xbcbcbcbcdededede;\r
2f88bd3a MK	355	Status = SafeUintnAdd (Augend, Addend, &Result);\r
2f88bd3a MK	356	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	357	\r
	358	return UNIT_TEST_PASSED;\r
	359	}\r
	360	\r
	361	UNIT_TEST_STATUS\r
	362	EFIAPI\r
	363	TestSafeIntnAdd (\r
2f88bd3a	364	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	365	)\r
	366	{\r
	367	EFI_STATUS Status;\r
	368	INTN Augend;\r
	369	INTN Addend;\r
	370	INTN Result;\r
	371	\r
	372	//\r
	373	// If the result of addition doesn't overflow MAX_INTN\r
	374	// and doesn't underflow MIN_INTN, then it's addition\r
	375	//\r
	376	Augend = 0x3a3a3a3a3a3a3a3a;\r
	377	Addend = 0x3a3a3a3a3a3a3a3a;\r
	378	Result = 0;\r
2f88bd3a MK	379	Status = SafeIntnAdd (Augend, Addend, &Result);\r
	380	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	381	UT_ASSERT_EQUAL (0x7474747474747474, Result);\r
e50c2bb3 MK	382	\r
	383	Augend = (-4195730024608447034);\r
	384	Addend = (-4195730024608447034);\r
2f88bd3a MK	385	Status = SafeIntnAdd (Augend, Addend, &Result);\r
	386	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	387	UT_ASSERT_EQUAL ((-8391460049216894068), Result);\r
e50c2bb3 MK	388	\r
	389	//\r
	390	// Otherwise should result in an error status\r
	391	//\r
	392	Augend = 0x5a5a5a5a5a5a5a5a;\r
	393	Addend = 0x5a5a5a5a5a5a5a5a;\r
2f88bd3a MK	394	Status = SafeIntnAdd (Augend, Addend, &Result);\r
2f88bd3a MK	395	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	396	\r
	397	Augend = (-6510615555426900570);\r
	398	Addend = (-6510615555426900570);\r
2f88bd3a MK	399	Status = SafeIntnAdd (Augend, Addend, &Result);\r
2f88bd3a MK	400	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	401	\r
	402	return UNIT_TEST_PASSED;\r
	403	}\r
	404	\r
	405	UNIT_TEST_STATUS\r
	406	EFIAPI\r
	407	TestSafeUintnSub (\r
2f88bd3a	408	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	409	)\r
	410	{\r
	411	EFI_STATUS Status;\r
	412	UINTN Minuend;\r
	413	UINTN Subtrahend;\r
	414	UINTN Result;\r
	415	\r
	416	//\r
	417	// If Minuend >= Subtrahend, then it's subtraction\r
	418	//\r
2f88bd3a	419	Minuend = 0x5a5a5a5a5a5a5a5a;\r
e50c2bb3	420	Subtrahend = 0x3b3b3b3b3b3b3b3b;\r
2f88bd3a MK	421	Result = 0;\r
	422	Status = SafeUintnSub (Minuend, Subtrahend, &Result);\r
	423	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	424	UT_ASSERT_EQUAL (0x1f1f1f1f1f1f1f1f, Result);\r
e50c2bb3 MK	425	\r
	426	//\r
	427	// Otherwise should result in an error status\r
	428	//\r
2f88bd3a	429	Minuend = 0x5a5a5a5a5a5a5a5a;\r
e50c2bb3	430	Subtrahend = 0x6d6d6d6d6d6d6d6d;\r
2f88bd3a MK	431	Status = SafeUintnSub (Minuend, Subtrahend, &Result);\r
2f88bd3a MK	432	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	433	\r
	434	return UNIT_TEST_PASSED;\r
	435	}\r
	436	\r
	437	UNIT_TEST_STATUS\r
	438	EFIAPI\r
	439	TestSafeIntnSub (\r
2f88bd3a	440	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	441	)\r
	442	{\r
	443	EFI_STATUS Status;\r
	444	INTN Minuend;\r
	445	INTN Subtrahend;\r
	446	INTN Result;\r
	447	\r
	448	//\r
	449	// If the result of subtractions doesn't overflow MAX_INTN or\r
	450	// underflow MIN_INTN, then it's subtraction\r
	451	//\r
2f88bd3a	452	Minuend = 0x5a5a5a5a5a5a5a5a;\r
e50c2bb3	453	Subtrahend = 0x3a3a3a3a3a3a3a3a;\r
2f88bd3a MK	454	Result = 0;\r
	455	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
	456	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	457	UT_ASSERT_EQUAL (0x2020202020202020, Result);\r
e50c2bb3	458	\r
2f88bd3a	459	Minuend = 0x3a3a3a3a3a3a3a3a;\r
e50c2bb3	460	Subtrahend = 0x5a5a5a5a5a5a5a5a;\r
2f88bd3a MK	461	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
	462	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	463	UT_ASSERT_EQUAL ((-2314885530818453536), Result);\r
e50c2bb3 MK	464	\r
	465	//\r
	466	// Otherwise should result in an error status\r
	467	//\r
2f88bd3a	468	Minuend = (-8825501086245354106);\r
e50c2bb3	469	Subtrahend = 8825501086245354106;\r
2f88bd3a MK	470	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
2f88bd3a MK	471	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3	472	\r
2f88bd3a	473	Minuend = (8825501086245354106);\r
e50c2bb3	474	Subtrahend = (-8825501086245354106);\r
2f88bd3a MK	475	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
2f88bd3a MK	476	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	477	\r
	478	return UNIT_TEST_PASSED;\r
	479	}\r
	480	\r
	481	UNIT_TEST_STATUS\r
	482	EFIAPI\r
	483	TestSafeUintnMult (\r
2f88bd3a	484	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	485	)\r
	486	{\r
	487	EFI_STATUS Status;\r
	488	UINTN Multiplicand;\r
	489	UINTN Multiplier;\r
	490	UINTN Result;\r
	491	\r
	492	//\r
	493	// If the result of multiplication doesn't overflow MAX_UINTN, it will succeed\r
	494	//\r
	495	Multiplicand = 0x123456789a;\r
2f88bd3a MK	496	Multiplier = 0x1234567;\r
	497	Result = 0;\r
	498	Status = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
	499	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	500	UT_ASSERT_EQUAL (0x14b66db9745a07f6, Result);\r
e50c2bb3 MK	501	\r
	502	//\r
	503	// Otherwise should result in an error status\r
	504	//\r
	505	Multiplicand = 0x123456789a;\r
2f88bd3a MK	506	Multiplier = 0x12345678;\r
	507	Status = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
	508	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	509	\r
	510	return UNIT_TEST_PASSED;\r
	511	}\r
	512	\r
	513	UNIT_TEST_STATUS\r
	514	EFIAPI\r
	515	TestSafeIntnMult (\r
2f88bd3a	516	IN UNIT_TEST_CONTEXT Context\r
e50c2bb3 MK	517	)\r
	518	{\r
	519	EFI_STATUS Status;\r
	520	INTN Multiplicand;\r
	521	INTN Multiplier;\r
	522	INTN Result;\r
	523	\r
	524	//\r
	525	// If the result of multiplication doesn't overflow MAX_INTN and doesn't\r
	526	// underflow MIN_UINTN, it will succeed\r
	527	//\r
	528	Multiplicand = 0x123456789;\r
2f88bd3a MK	529	Multiplier = 0x6789abcd;\r
	530	Result = 0;\r
	531	Status = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
	532	UT_ASSERT_NOT_EFI_ERROR (Status);\r
	533	UT_ASSERT_EQUAL (0x75cd9045220d6bb5, Result);\r
e50c2bb3 MK	534	\r
	535	//\r
	536	// Otherwise should result in an error status\r
	537	//\r
	538	Multiplicand = 0x123456789;\r
2f88bd3a MK	539	Multiplier = 0xa789abcd;\r
	540	Status = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
	541	UT_ASSERT_EQUAL (RETURN_BUFFER_TOO_SMALL, Status);\r
e50c2bb3 MK	542	\r
	543	return UNIT_TEST_PASSED;\r
	544	}\r