78 GTEST_SKIP() <<
"ENABLE_VOIDSTAR is a debug build, but does not crash on failed asserts.";
80 auto const smallConstruct = [] {
84 Blob const tooSmall{1, 2, 3, 4, 5, 6, 7, 8};
85 BaseUInt96
const result = BaseUInt96::fromRaw(tooSmall);
86 auto const resultText =
to_string(result);
87 EXPECT_EQ(resultText,
"010203040506070800000000") << resultText;
89 EXPECT_DEBUG_DEATH(smallConstruct(),
"input size match");
91 auto const largeConstruct = [] {
95 Blob const tooBig{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
96 BaseUInt96
const result = BaseUInt96::fromRaw(tooBig);
97 auto const resultText =
to_string(result);
98 EXPECT_EQ(resultText,
"0102030405060708090A0B0C") << resultText;
100 EXPECT_DEBUG_DEATH(largeConstruct(),
"input size match");
102 auto const smallCopy = [] {
106 Blob const tooSmall{1, 2, 3, 4, 5, 6, 7, 8};
110 auto const originalText =
to_string(result);
111 EXPECT_EQ(originalText,
"FFFFFFFFFFFFFFFFFFFFFFFF") << originalText;
114 auto const resultText =
to_string(result);
115 EXPECT_EQ(resultText,
"010203040506070800000000") << resultText;
117 EXPECT_DEBUG_DEATH(smallCopy(),
"input size match");
119 auto const largeCopy = [] {
123 Blob const tooBig{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16};
127 auto const originalText =
to_string(result);
128 EXPECT_EQ(originalText,
"FFFFFFFFFFFFFFFFFFFFFFFF") << originalText;
131 auto const resultText =
to_string(result);
132 EXPECT_EQ(resultText,
"0102030405060708090A0B0C") << resultText;
134 EXPECT_DEBUG_DEATH(largeCopy(),
"input size match");
143 static constexpr auto kTestArgs = std::to_array<HexPair>({
144 {
"0000000000000000",
"0000000000000001"},
145 {
"0000000000000000",
"ffffffffffffffff"},
146 {
"1234567812345678",
"2345678923456789"},
147 {
"8000000000000000",
"8000000000000001"},
148 {
"aaaaaaaaaaaaaaa9",
"aaaaaaaaaaaaaaaa"},
149 {
"fffffffffffffffe",
"ffffffffffffffff"},
152 for (
auto const& [smallerText, largerText] : kTestArgs)
157 EXPECT_TRUE(smaller < larger);
158 EXPECT_TRUE(smaller <= larger);
159 EXPECT_TRUE(smaller != larger);
160 EXPECT_FALSE(smaller == larger);
161 EXPECT_FALSE(smaller > larger);
162 EXPECT_FALSE(smaller >= larger);
163 EXPECT_FALSE(larger < smaller);
164 EXPECT_FALSE(larger <= smaller);
165 EXPECT_TRUE(larger != smaller);
166 EXPECT_FALSE(larger == smaller);
167 EXPECT_TRUE(larger > smaller);
168 EXPECT_TRUE(larger >= smaller);
169 EXPECT_TRUE(smaller == smaller);
170 EXPECT_TRUE(larger == larger);
175 static constexpr auto kTestArgs = std::to_array<HexPair>({
176 {
"000000000000000000000000",
"000000000000000000000001"},
177 {
"000000000000000000000000",
"ffffffffffffffffffffffff"},
178 {
"0123456789ab0123456789ab",
"123456789abc123456789abc"},
179 {
"555555555555555555555555",
"55555555555a555555555555"},
180 {
"aaaaaaaaaaaaaaa9aaaaaaaa",
"aaaaaaaaaaaaaaaaaaaaaaaa"},
181 {
"fffffffffffffffffffffffe",
"ffffffffffffffffffffffff"},
184 for (
auto const& [smallerText, largerText] : kTestArgs)
187 EXPECT_TRUE(smaller < larger);
188 EXPECT_TRUE(smaller <= larger);
189 EXPECT_TRUE(smaller != larger);
190 EXPECT_FALSE(smaller == larger);
191 EXPECT_FALSE(smaller > larger);
192 EXPECT_FALSE(smaller >= larger);
193 EXPECT_FALSE(larger < smaller);
194 EXPECT_FALSE(larger <= smaller);
195 EXPECT_TRUE(larger != smaller);
196 EXPECT_FALSE(larger == smaller);
197 EXPECT_TRUE(larger > smaller);
198 EXPECT_TRUE(larger >= smaller);
199 EXPECT_TRUE(smaller == smaller);
200 EXPECT_TRUE(larger == larger);
207 EXPECT_EQ(BaseUInt96::kBytes, raw.size());
208 EXPECT_EQ(raw.size(), ascending.size());
209 EXPECT_EQ(
to_string(ascending),
"0102030405060708090A0B0C");
211 EXPECT_EQ(*ascending.data(), 1);
212 EXPECT_EQ(ascending.signum(), 1);
213 EXPECT_FALSE(!ascending);
214 EXPECT_FALSE(ascending.isZero());
215 EXPECT_TRUE(ascending.isNonZero());
217 unsigned char expectedByte = 0;
218 for (
auto const&
byte : ascending)
219 EXPECT_EQ(
byte, ++expectedByte);
236 EXPECT_EQ(
to_string(complement),
"FEFDFCFBFAF9F8F7F6F5F4F3");
238 EXPECT_EQ(*complement.data(), 0xfe);
239 EXPECT_EQ(complement.signum(), 1);
240 EXPECT_FALSE(!complement);
241 EXPECT_FALSE(complement.isZero());
242 EXPECT_TRUE(complement.isNonZero());
244 unsigned char expectedByte = 0xff;
245 for (
auto const&
byte : complement)
246 EXPECT_EQ(
byte, --expectedByte);
248 EXPECT_LT(ascending, complement);
249 EXPECT_GT(complement, ascending);
251 BaseUInt96 assigned{complement};
252 assigned = ascending;
253 EXPECT_EQ(assigned, ascending);
258 EXPECT_EQ(
to_string(zero),
"000000000000000000000000");
260 EXPECT_EQ(*zero.data(), 0);
261 EXPECT_EQ(*zero.begin(), 0);
263 EXPECT_EQ(zero.signum(), 0);
265 EXPECT_TRUE(zero.isZero());
266 EXPECT_FALSE(zero.isNonZero());
268 for (
auto const&
byte : zero)
274 BaseUInt96
const defaultZero;
275 EXPECT_EQ(defaultZero, zero) <<
to_string(defaultZero);
277 BaseUInt96
const bracedZero{};
278 EXPECT_EQ(bracedZero, zero) <<
to_string(bracedZero);
280 BaseUInt96
const zeroFromUInt{0u};
281 EXPECT_EQ(zeroFromUInt, zero) <<
to_string(zeroFromUInt);
286 BaseUInt96 counter{zero};
289 EXPECT_EQ(counter, BaseUInt96(1));
293 EXPECT_EQ(counter, zero);
297 EXPECT_EQ(
to_string(counter),
"FFFFFFFFFFFFFFFFFFFFFFFF");
301 EXPECT_EQ(counter, zero);
424 char const*
const str;
427 constexpr StrBaseUInt(
char const* s) : str(s), tst(s)
432 constexpr auto kTestCases = std::to_array<StrBaseUInt>({
433 "000000000000000000000000",
434 "000000000000000000000001",
435 "fedcba9876543210ABCDEF91",
436 "19FEDCBA0123456789abcdef",
437 "800000000000000000000000",
438 "fFfFfFfFfFfFfFfFfFfFfFfF",
441 for (StrBaseUInt
const& testCase : kTestCases)
444 EXPECT_TRUE(t96.parseHex(testCase.str));
445 EXPECT_EQ(t96, testCase.tst);