[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
	16	IN UNIT_TEST_CONTEXT Context\r
	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
	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
	31	\r
	32	//\r
	33	// Otherwise should result in an error status\r
	34	//\r
	35	Operand = (-1537977259);\r
	36	Status = SafeInt32ToUintn(Operand, &Result);\r
	37	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
	38	\r
	39	return UNIT_TEST_PASSED;\r
	40	}\r
	41	\r
	42	UNIT_TEST_STATUS\r
	43	EFIAPI\r
	44	TestSafeUint32ToIntn (\r
	45	IN UNIT_TEST_CONTEXT Context\r
	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
	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
65	\r
66	return UNIT_TEST_PASSED;\r
67	}\r
68	\r
69	UNIT_TEST_STATUS\r
70	EFIAPI\r
71	TestSafeIntnToInt32 (\r
72	IN UNIT_TEST_CONTEXT Context\r
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
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
87	\r
88	Operand = (-1537977259);\r
89	Status = SafeIntnToInt32(Operand, &Result);\r
90	UT_ASSERT_NOT_EFI_ERROR(Status);\r
91	UT_ASSERT_EQUAL((-1537977259), Result);\r
92	\r
93	//\r
94	// Otherwise should result in an error status\r
95	//\r
96	Operand = (0x5babababefefefef);\r
97	Status = SafeIntnToInt32(Operand, &Result);\r
98	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
99	\r
100	Operand = (-6605562033422200815);\r
101	Status = SafeIntnToInt32(Operand, &Result);\r
102	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
103	\r
104	return UNIT_TEST_PASSED;\r
105	}\r
106	\r
107	UNIT_TEST_STATUS\r
108	EFIAPI\r
109	TestSafeIntnToUint32 (\r
110	IN UNIT_TEST_CONTEXT Context\r
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
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
125	\r
126	//\r
127	// Otherwise should result in an error status\r
128	//\r
129	Operand = (0x5babababefefefef);\r
130	Status = SafeIntnToUint32(Operand, &Result);\r
131	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
132	\r
133	Operand = (-6605562033422200815);\r
134	Status = SafeIntnToUint32(Operand, &Result);\r
135	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
136	\r
137	return UNIT_TEST_PASSED;\r
138	}\r
139	\r
140	UNIT_TEST_STATUS\r
141	EFIAPI\r
142	TestSafeUintnToUint32 (\r
143	IN UNIT_TEST_CONTEXT Context\r
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
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
158	\r
159	//\r
160	// Otherwise should result in an error status\r
161	//\r
162	Operand = (0xababababefefefef);\r
163	Status = SafeUintnToUint32(Operand, &Result);\r
164	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
165	\r
166	return UNIT_TEST_PASSED;\r
167	}\r
168	\r
169	UNIT_TEST_STATUS\r
170	EFIAPI\r
171	TestSafeUintnToIntn (\r
172	IN UNIT_TEST_CONTEXT Context\r
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
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
187	\r
188	//\r
189	// Otherwise should result in an error status\r
190	//\r
191	Operand = (0xababababefefefef);\r
192	Status = SafeUintnToIntn(Operand, &Result);\r
193	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
194	\r
195	return UNIT_TEST_PASSED;\r
196	}\r
197	\r
198	UNIT_TEST_STATUS\r
199	EFIAPI\r
200	TestSafeUintnToInt64 (\r
201	IN UNIT_TEST_CONTEXT Context\r
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
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
216	\r
217	//\r
218	// Otherwise should result in an error status\r
219	//\r
220	Operand = (0xababababefefefef);\r
221	Status = SafeUintnToInt64(Operand, &Result);\r
222	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
223	\r
224	return UNIT_TEST_PASSED;\r
225	}\r
226	\r
227	UNIT_TEST_STATUS\r
228	EFIAPI\r
229	TestSafeInt64ToIntn (\r
230	IN UNIT_TEST_CONTEXT Context\r
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
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
245	\r
246	return UNIT_TEST_PASSED;\r
247	}\r
248	\r
249	UNIT_TEST_STATUS\r
250	EFIAPI\r
251	TestSafeInt64ToUintn (\r
252	IN UNIT_TEST_CONTEXT Context\r
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
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
267	\r
268	//\r
269	// Otherwise should result in an error status\r
270	//\r
271	Operand = (-6605562033422200815);\r
272	Status = SafeInt64ToUintn(Operand, &Result);\r
273	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
274	\r
275	return UNIT_TEST_PASSED;\r
276	}\r
277	\r
278	UNIT_TEST_STATUS\r
279	EFIAPI\r
280	TestSafeUint64ToIntn (\r
281	IN UNIT_TEST_CONTEXT Context\r
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
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
296	\r
297	//\r
298	// Otherwise should result in an error status\r
299	//\r
300	Operand = (0xababababefefefef);\r
301	Status = SafeUint64ToIntn(Operand, &Result);\r
302	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
303	\r
304	return UNIT_TEST_PASSED;\r
305	}\r
306	\r
307	UNIT_TEST_STATUS\r
308	EFIAPI\r
309	TestSafeUint64ToUintn (\r
310	IN UNIT_TEST_CONTEXT Context\r
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
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
325	\r
326	return UNIT_TEST_PASSED;\r
327	}\r
328	\r
329	UNIT_TEST_STATUS\r
330	EFIAPI\r
331	TestSafeUintnAdd (\r
332	IN UNIT_TEST_CONTEXT Context\r
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
346	Status = SafeUintnAdd(Augend, Addend, &Result);\r
347	UT_ASSERT_NOT_EFI_ERROR(Status);\r
348	UT_ASSERT_EQUAL(0x7474747424242424, Result);\r
349	\r
350	//\r
351	// Otherwise should result in an error status\r
352	//\r
353	Augend = 0xababababefefefef;\r
354	Addend = 0xbcbcbcbcdededede;\r
355	Status = SafeUintnAdd(Augend, Addend, &Result);\r
356	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
357	\r
358	return UNIT_TEST_PASSED;\r
359	}\r
360	\r
361	UNIT_TEST_STATUS\r
362	EFIAPI\r
363	TestSafeIntnAdd (\r
364	IN UNIT_TEST_CONTEXT Context\r
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
379	Status = SafeIntnAdd(Augend, Addend, &Result);\r
380	UT_ASSERT_NOT_EFI_ERROR(Status);\r
381	UT_ASSERT_EQUAL(0x7474747474747474, Result);\r
382	\r
383	Augend = (-4195730024608447034);\r
384	Addend = (-4195730024608447034);\r
385	Status = SafeIntnAdd(Augend, Addend, &Result);\r
386	UT_ASSERT_NOT_EFI_ERROR(Status);\r
387	UT_ASSERT_EQUAL((-8391460049216894068), Result);\r
388	\r
389	//\r
390	// Otherwise should result in an error status\r
391	//\r
392	Augend = 0x5a5a5a5a5a5a5a5a;\r
393	Addend = 0x5a5a5a5a5a5a5a5a;\r
394	Status = SafeIntnAdd(Augend, Addend, &Result);\r
395	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
396	\r
397	Augend = (-6510615555426900570);\r
398	Addend = (-6510615555426900570);\r
399	Status = SafeIntnAdd(Augend, Addend, &Result);\r
400	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
401	\r
402	return UNIT_TEST_PASSED;\r
403	}\r
404	\r
405	UNIT_TEST_STATUS\r
406	EFIAPI\r
407	TestSafeUintnSub (\r
408	IN UNIT_TEST_CONTEXT Context\r
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
419	Minuend = 0x5a5a5a5a5a5a5a5a;\r
420	Subtrahend = 0x3b3b3b3b3b3b3b3b;\r
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
425	\r
426	//\r
427	// Otherwise should result in an error status\r
428	//\r
429	Minuend = 0x5a5a5a5a5a5a5a5a;\r
430	Subtrahend = 0x6d6d6d6d6d6d6d6d;\r
431	Status = SafeUintnSub(Minuend, Subtrahend, &Result);\r
432	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
433	\r
434	return UNIT_TEST_PASSED;\r
435	}\r
436	\r
437	UNIT_TEST_STATUS\r
438	EFIAPI\r
439	TestSafeIntnSub (\r
440	IN UNIT_TEST_CONTEXT Context\r
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
452	Minuend = 0x5a5a5a5a5a5a5a5a;\r
453	Subtrahend = 0x3a3a3a3a3a3a3a3a;\r
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
458	\r
459	Minuend = 0x3a3a3a3a3a3a3a3a;\r
460	Subtrahend = 0x5a5a5a5a5a5a5a5a;\r
461	Status = SafeIntnSub(Minuend, Subtrahend, &Result);\r
462	UT_ASSERT_NOT_EFI_ERROR(Status);\r
463	UT_ASSERT_EQUAL((-2314885530818453536), Result);\r
464	\r
465	//\r
466	// Otherwise should result in an error status\r
467	//\r
468	Minuend = (-8825501086245354106);\r
469	Subtrahend = 8825501086245354106;\r
470	Status = SafeIntnSub(Minuend, Subtrahend, &Result);\r
471	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
472	\r
473	Minuend = (8825501086245354106);\r
474	Subtrahend = (-8825501086245354106);\r
475	Status = SafeIntnSub(Minuend, Subtrahend, &Result);\r
476	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
477	\r
478	return UNIT_TEST_PASSED;\r
479	}\r
480	\r
481	UNIT_TEST_STATUS\r
482	EFIAPI\r
483	TestSafeUintnMult (\r
484	IN UNIT_TEST_CONTEXT Context\r
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
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
501	\r
502	//\r
503	// Otherwise should result in an error status\r
504	//\r
505	Multiplicand = 0x123456789a;\r
506	Multiplier = 0x12345678;\r
507	Status = SafeUintnMult(Multiplicand, Multiplier, &Result);\r
508	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
509	\r
510	return UNIT_TEST_PASSED;\r
511	}\r
512	\r
513	UNIT_TEST_STATUS\r
514	EFIAPI\r
515	TestSafeIntnMult (\r
516	IN UNIT_TEST_CONTEXT Context\r
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
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
534	\r
535	//\r
536	// Otherwise should result in an error status\r
537	//\r
538	Multiplicand = 0x123456789;\r
539	Multiplier = 0xa789abcd;\r
540	Status = SafeIntnMult(Multiplicand, Multiplier, &Result);\r
541	UT_ASSERT_EQUAL(RETURN_BUFFER_TOO_SMALL, Status);\r
542	\r
543	return UNIT_TEST_PASSED;\r
544	}\r