[mirror_edk2.git] / MdePkg / Test / GoogleTest / Library / BaseSafeIntLib / SafeIntLibUintnIntnUnitTests64.cpp

/** @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 <gtest/gtest.h>\r
extern "C" {\r
  #include <Base.h>\r
  #include <Library/SafeIntLib.h>\r
}\r
\r
TEST(ConversionTestSuite, TestSafeInt32ToUintn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((UINTN)0x5bababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (-1537977259);\r
  Status  = SafeInt32ToUintn (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUint32ToIntn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0xabababab, Result);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeIntnToInt32) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x5bababab, Result);\r
\r
  Operand = (-1537977259);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((-1537977259), Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0x5babababefefefef);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeIntnToInt32 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeIntnToUint32) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0xabababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0x5babababefefefef);\r
  Status  = SafeIntnToUint32 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeIntnToUint32 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUintnToUint32) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0xabababab, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToUint32 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUintnToIntn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToIntn (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUintnToInt64) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUintnToInt64 (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeInt64ToIntn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x5babababefefefef, Result);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeInt64ToUintn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((UINTN)0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand =  (-6605562033422200815);\r
  Status  = SafeInt64ToUintn (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUint64ToIntn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x5babababefefefef, Result);\r
\r
  //\r
  // Otherwise should result in an error status\r
  //\r
  Operand = (0xababababefefefef);\r
  Status  = SafeUint64ToIntn (Operand, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(ConversionTestSuite, TestSafeUint64ToUintn) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0xababababefefefef, Result);\r
}\r
\r
TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((UINTN)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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x7474747474747474, Result);\r
\r
  Augend = (-4195730024608447034);\r
  Addend = (-4195730024608447034);\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((-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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Augend = (-6510615555426900570);\r
  Addend = (-6510615555426900570);\r
  Status = SafeIntnAdd (Augend, Addend, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((UINTN)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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (0x2020202020202020, Result);\r
\r
  Minuend    = 0x3a3a3a3a3a3a3a3a;\r
  Subtrahend = 0x5a5a5a5a5a5a5a5a;\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((-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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
\r
  Minuend    = (8825501086245354106);\r
  Subtrahend = (-8825501086245354106);\r
  Status     = SafeIntnSub (Minuend, Subtrahend, &Result);\r
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(MultiplicationTestSuite, TestSafeUintnMult) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ ((UINTN)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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
\r
TEST(MultiplicationTestSuite, TestSafeIntnMult) {\r
  RETURN_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
  ASSERT_EQ (Status, RETURN_SUCCESS);\r
  ASSERT_EQ (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
  ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
}\r
Commit	Line	Data
6d55ad9a 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 <gtest/gtest.h>\r
	12	extern "C" {\r
	13	#include <Base.h>\r
	14	#include <Library/SafeIntLib.h>\r
	15	}\r
	16	\r
	17	TEST(ConversionTestSuite, TestSafeInt32ToUintn) {\r
	18	RETURN_STATUS Status;\r
	19	INT32 Operand;\r
	20	UINTN Result;\r
	21	\r
	22	//\r
	23	// If Operand is non-negative, then it's a cast\r
	24	//\r
	25	Operand = 0x5bababab;\r
	26	Result = 0;\r
	27	Status = SafeInt32ToUintn (Operand, &Result);\r
	28	ASSERT_EQ (Status, RETURN_SUCCESS);\r
	29	ASSERT_EQ ((UINTN)0x5bababab, Result);\r
	30	\r
	31	//\r
	32	// Otherwise should result in an error status\r
	33	//\r
	34	Operand = (-1537977259);\r
	35	Status = SafeInt32ToUintn (Operand, &Result);\r
	36	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
	37	}\r
	38	\r
	39	TEST(ConversionTestSuite, TestSafeUint32ToIntn) {\r
	40	RETURN_STATUS Status;\r
	41	UINT32 Operand;\r
	42	INTN Result;\r
	43	\r
	44	//\r
	45	// For x64, INTN is same as INT64 which is a superset of INT32\r
	46	// This is just a cast then, and it'll never fail\r
	47	//\r
	48	\r
	49	//\r
	50	// If Operand is non-negative, then it's a cast\r
	51	//\r
	52	Operand = 0xabababab;\r
	53	Result = 0;\r
	54	Status = SafeUint32ToIntn (Operand, &Result);\r
	55	ASSERT_EQ (Status, RETURN_SUCCESS);\r
	56	ASSERT_EQ (0xabababab, Result);\r
	57	}\r
	58	\r
	59	TEST(ConversionTestSuite, TestSafeIntnToInt32) {\r
	60	RETURN_STATUS Status;\r
	61	INTN Operand;\r
	62	INT32 Result;\r
	63	\r
	64	//\r
65	// If Operand is between MIN_INT32 and MAX_INT32 inclusive, then it's a cast\r
66	//\r
67	Operand = 0x5bababab;\r
68	Result = 0;\r
69	Status = SafeIntnToInt32 (Operand, &Result);\r
70	ASSERT_EQ (Status, RETURN_SUCCESS);\r
71	ASSERT_EQ (0x5bababab, Result);\r
72	\r
73	Operand = (-1537977259);\r
74	Status = SafeIntnToInt32 (Operand, &Result);\r
75	ASSERT_EQ (Status, RETURN_SUCCESS);\r
76	ASSERT_EQ ((-1537977259), Result);\r
77	\r
78	//\r
79	// Otherwise should result in an error status\r
80	//\r
81	Operand = (0x5babababefefefef);\r
82	Status = SafeIntnToInt32 (Operand, &Result);\r
83	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
84	\r
85	Operand = (-6605562033422200815);\r
86	Status = SafeIntnToInt32 (Operand, &Result);\r
87	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
88	}\r
89	\r
90	TEST(ConversionTestSuite, TestSafeIntnToUint32) {\r
91	RETURN_STATUS Status;\r
92	INTN Operand;\r
93	UINT32 Result;\r
94	\r
95	//\r
96	// If Operand is between 0 and MAX_UINT32 inclusive, then it's a cast\r
97	//\r
98	Operand = 0xabababab;\r
99	Result = 0;\r
100	Status = SafeIntnToUint32 (Operand, &Result);\r
101	ASSERT_EQ (Status, RETURN_SUCCESS);\r
102	ASSERT_EQ (0xabababab, Result);\r
103	\r
104	//\r
105	// Otherwise should result in an error status\r
106	//\r
107	Operand = (0x5babababefefefef);\r
108	Status = SafeIntnToUint32 (Operand, &Result);\r
109	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
110	\r
111	Operand = (-6605562033422200815);\r
112	Status = SafeIntnToUint32 (Operand, &Result);\r
113	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
114	}\r
115	\r
116	TEST(ConversionTestSuite, TestSafeUintnToUint32) {\r
117	RETURN_STATUS Status;\r
118	UINTN Operand;\r
119	UINT32 Result;\r
120	\r
121	//\r
122	// If Operand is <= MAX_UINT32, then it's a cast\r
123	//\r
124	Operand = 0xabababab;\r
125	Result = 0;\r
126	Status = SafeUintnToUint32 (Operand, &Result);\r
127	ASSERT_EQ (Status, RETURN_SUCCESS);\r
128	ASSERT_EQ (0xabababab, Result);\r
129	\r
130	//\r
131	// Otherwise should result in an error status\r
132	//\r
133	Operand = (0xababababefefefef);\r
134	Status = SafeUintnToUint32 (Operand, &Result);\r
135	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
136	}\r
137	\r
138	TEST(ConversionTestSuite, TestSafeUintnToIntn) {\r
139	RETURN_STATUS Status;\r
140	UINTN Operand;\r
141	INTN Result;\r
142	\r
143	//\r
144	// If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
145	//\r
146	Operand = 0x5babababefefefef;\r
147	Result = 0;\r
148	Status = SafeUintnToIntn (Operand, &Result);\r
149	ASSERT_EQ (Status, RETURN_SUCCESS);\r
150	ASSERT_EQ (0x5babababefefefef, Result);\r
151	\r
152	//\r
153	// Otherwise should result in an error status\r
154	//\r
155	Operand = (0xababababefefefef);\r
156	Status = SafeUintnToIntn (Operand, &Result);\r
157	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
158	}\r
159	\r
160	TEST(ConversionTestSuite, TestSafeUintnToInt64) {\r
161	RETURN_STATUS Status;\r
162	UINTN Operand;\r
163	INT64 Result;\r
164	\r
165	//\r
166	// If Operand is <= MAX_INT64, then it's a cast\r
167	//\r
168	Operand = 0x5babababefefefef;\r
169	Result = 0;\r
170	Status = SafeUintnToInt64 (Operand, &Result);\r
171	ASSERT_EQ (Status, RETURN_SUCCESS);\r
172	ASSERT_EQ (0x5babababefefefef, Result);\r
173	\r
174	//\r
175	// Otherwise should result in an error status\r
176	//\r
177	Operand = (0xababababefefefef);\r
178	Status = SafeUintnToInt64 (Operand, &Result);\r
179	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
180	}\r
181	\r
182	TEST(ConversionTestSuite, TestSafeInt64ToIntn) {\r
183	RETURN_STATUS Status;\r
184	INT64 Operand;\r
185	INTN Result;\r
186	\r
187	//\r
188	// INTN is same as INT64 in x64, so this is just a cast\r
189	//\r
190	Operand = 0x5babababefefefef;\r
191	Result = 0;\r
192	Status = SafeInt64ToIntn (Operand, &Result);\r
193	ASSERT_EQ (Status, RETURN_SUCCESS);\r
194	ASSERT_EQ (0x5babababefefefef, Result);\r
195	}\r
196	\r
197	TEST(ConversionTestSuite, TestSafeInt64ToUintn) {\r
198	RETURN_STATUS Status;\r
199	INT64 Operand;\r
200	UINTN Result;\r
201	\r
202	//\r
203	// If Operand is non-negative, then it's a cast\r
204	//\r
205	Operand = 0x5babababefefefef;\r
206	Result = 0;\r
207	Status = SafeInt64ToUintn (Operand, &Result);\r
208	ASSERT_EQ (Status, RETURN_SUCCESS);\r
209	ASSERT_EQ ((UINTN)0x5babababefefefef, Result);\r
210	\r
211	//\r
212	// Otherwise should result in an error status\r
213	//\r
214	Operand = (-6605562033422200815);\r
215	Status = SafeInt64ToUintn (Operand, &Result);\r
216	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
217	}\r
218	\r
219	TEST(ConversionTestSuite, TestSafeUint64ToIntn) {\r
220	RETURN_STATUS Status;\r
221	UINT64 Operand;\r
222	INTN Result;\r
223	\r
224	//\r
225	// If Operand is <= MAX_INTN (0x7fff_ffff_ffff_ffff), then it's a cast\r
226	//\r
227	Operand = 0x5babababefefefef;\r
228	Result = 0;\r
229	Status = SafeUint64ToIntn (Operand, &Result);\r
230	ASSERT_EQ (Status, RETURN_SUCCESS);\r
231	ASSERT_EQ (0x5babababefefefef, Result);\r
232	\r
233	//\r
234	// Otherwise should result in an error status\r
235	//\r
236	Operand = (0xababababefefefef);\r
237	Status = SafeUint64ToIntn (Operand, &Result);\r
238	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
239	}\r
240	\r
241	TEST(ConversionTestSuite, TestSafeUint64ToUintn) {\r
242	RETURN_STATUS Status;\r
243	UINT64 Operand;\r
244	UINTN Result;\r
245	\r
246	//\r
247	// UINTN is same as UINT64 in x64, so this is just a cast\r
248	//\r
249	Operand = 0xababababefefefef;\r
250	Result = 0;\r
251	Status = SafeUint64ToUintn (Operand, &Result);\r
252	ASSERT_EQ (Status, RETURN_SUCCESS);\r
253	ASSERT_EQ (0xababababefefefef, Result);\r
254	}\r
255	\r
256	TEST(AdditionSubtractionTestSuite, TestSafeUintnAdd) {\r
257	RETURN_STATUS Status;\r
258	UINTN Augend;\r
259	UINTN Addend;\r
260	UINTN Result;\r
261	\r
262	//\r
263	// If the result of addition doesn't overflow MAX_UINTN, then it's addition\r
264	//\r
265	Augend = 0x3a3a3a3a12121212;\r
266	Addend = 0x3a3a3a3a12121212;\r
267	Result = 0;\r
268	Status = SafeUintnAdd (Augend, Addend, &Result);\r
269	ASSERT_EQ (Status, RETURN_SUCCESS);\r
270	ASSERT_EQ ((UINTN)0x7474747424242424, Result);\r
271	\r
272	//\r
273	// Otherwise should result in an error status\r
274	//\r
275	Augend = 0xababababefefefef;\r
276	Addend = 0xbcbcbcbcdededede;\r
277	Status = SafeUintnAdd (Augend, Addend, &Result);\r
278	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
279	}\r
280	\r
281	TEST(AdditionSubtractionTestSuite, TestSafeIntnAdd) {\r
282	RETURN_STATUS Status;\r
283	INTN Augend;\r
284	INTN Addend;\r
285	INTN Result;\r
286	\r
287	//\r
288	// If the result of addition doesn't overflow MAX_INTN\r
289	// and doesn't underflow MIN_INTN, then it's addition\r
290	//\r
291	Augend = 0x3a3a3a3a3a3a3a3a;\r
292	Addend = 0x3a3a3a3a3a3a3a3a;\r
293	Result = 0;\r
294	Status = SafeIntnAdd (Augend, Addend, &Result);\r
295	ASSERT_EQ (Status, RETURN_SUCCESS);\r
296	ASSERT_EQ (0x7474747474747474, Result);\r
297	\r
298	Augend = (-4195730024608447034);\r
299	Addend = (-4195730024608447034);\r
300	Status = SafeIntnAdd (Augend, Addend, &Result);\r
301	ASSERT_EQ (Status, RETURN_SUCCESS);\r
302	ASSERT_EQ ((-8391460049216894068), Result);\r
303	\r
304	//\r
305	// Otherwise should result in an error status\r
306	//\r
307	Augend = 0x5a5a5a5a5a5a5a5a;\r
308	Addend = 0x5a5a5a5a5a5a5a5a;\r
309	Status = SafeIntnAdd (Augend, Addend, &Result);\r
310	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
311	\r
312	Augend = (-6510615555426900570);\r
313	Addend = (-6510615555426900570);\r
314	Status = SafeIntnAdd (Augend, Addend, &Result);\r
315	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
316	}\r
317	\r
318	TEST(AdditionSubtractionTestSuite, TestSafeUintnSub) {\r
319	RETURN_STATUS Status;\r
320	UINTN Minuend;\r
321	UINTN Subtrahend;\r
322	UINTN Result;\r
323	\r
324	//\r
325	// If Minuend >= Subtrahend, then it's subtraction\r
326	//\r
327	Minuend = 0x5a5a5a5a5a5a5a5a;\r
328	Subtrahend = 0x3b3b3b3b3b3b3b3b;\r
329	Result = 0;\r
330	Status = SafeUintnSub (Minuend, Subtrahend, &Result);\r
331	ASSERT_EQ (Status, RETURN_SUCCESS);\r
332	ASSERT_EQ ((UINTN)0x1f1f1f1f1f1f1f1f, Result);\r
333	\r
334	//\r
335	// Otherwise should result in an error status\r
336	//\r
337	Minuend = 0x5a5a5a5a5a5a5a5a;\r
338	Subtrahend = 0x6d6d6d6d6d6d6d6d;\r
339	Status = SafeUintnSub (Minuend, Subtrahend, &Result);\r
340	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
341	}\r
342	\r
343	TEST(AdditionSubtractionTestSuite, TestSafeIntnSub) {\r
344	RETURN_STATUS Status;\r
345	INTN Minuend;\r
346	INTN Subtrahend;\r
347	INTN Result;\r
348	\r
349	//\r
350	// If the result of subtractions doesn't overflow MAX_INTN or\r
351	// underflow MIN_INTN, then it's subtraction\r
352	//\r
353	Minuend = 0x5a5a5a5a5a5a5a5a;\r
354	Subtrahend = 0x3a3a3a3a3a3a3a3a;\r
355	Result = 0;\r
356	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
357	ASSERT_EQ (Status, RETURN_SUCCESS);\r
358	ASSERT_EQ (0x2020202020202020, Result);\r
359	\r
360	Minuend = 0x3a3a3a3a3a3a3a3a;\r
361	Subtrahend = 0x5a5a5a5a5a5a5a5a;\r
362	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
363	ASSERT_EQ (Status, RETURN_SUCCESS);\r
364	ASSERT_EQ ((-2314885530818453536), Result);\r
365	\r
366	//\r
367	// Otherwise should result in an error status\r
368	//\r
369	Minuend = (-8825501086245354106);\r
370	Subtrahend = 8825501086245354106;\r
371	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
372	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
373	\r
374	Minuend = (8825501086245354106);\r
375	Subtrahend = (-8825501086245354106);\r
376	Status = SafeIntnSub (Minuend, Subtrahend, &Result);\r
377	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
378	}\r
379	\r
380	TEST(MultiplicationTestSuite, TestSafeUintnMult) {\r
381	RETURN_STATUS Status;\r
382	UINTN Multiplicand;\r
383	UINTN Multiplier;\r
384	UINTN Result;\r
385	\r
386	//\r
387	// If the result of multiplication doesn't overflow MAX_UINTN, it will succeed\r
388	//\r
389	Multiplicand = 0x123456789a;\r
390	Multiplier = 0x1234567;\r
391	Result = 0;\r
392	Status = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
393	ASSERT_EQ (Status, RETURN_SUCCESS);\r
394	ASSERT_EQ ((UINTN)0x14b66db9745a07f6, Result);\r
395	\r
396	//\r
397	// Otherwise should result in an error status\r
398	//\r
399	Multiplicand = 0x123456789a;\r
400	Multiplier = 0x12345678;\r
401	Status = SafeUintnMult (Multiplicand, Multiplier, &Result);\r
402	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
403	}\r
404	\r
405	TEST(MultiplicationTestSuite, TestSafeIntnMult) {\r
406	RETURN_STATUS Status;\r
407	INTN Multiplicand;\r
408	INTN Multiplier;\r
409	INTN Result;\r
410	\r
411	//\r
412	// If the result of multiplication doesn't overflow MAX_INTN and doesn't\r
413	// underflow MIN_UINTN, it will succeed\r
414	//\r
415	Multiplicand = 0x123456789;\r
416	Multiplier = 0x6789abcd;\r
417	Result = 0;\r
418	Status = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
419	ASSERT_EQ (Status, RETURN_SUCCESS);\r
420	ASSERT_EQ (0x75cd9045220d6bb5, Result);\r
421	\r
422	//\r
423	// Otherwise should result in an error status\r
424	//\r
425	Multiplicand = 0x123456789;\r
426	Multiplier = 0xa789abcd;\r
427	Status = SafeIntnMult (Multiplicand, Multiplier, &Result);\r
428	ASSERT_EQ (RETURN_BUFFER_TOO_SMALL, Status);\r
429	}\r