1 // Formatting library for C++ - formatting library implementation tests
2 //
3 // Copyright (c) 2012 - present, Victor Zverovich
4 // All rights reserved.
5 //
6 // For the license information refer to format.h.
7
8 #define FMT_NOEXCEPT
9 #undef FMT_SHARED
10 #include "test-assert.h"
11
12 // Include format.cc instead of format.h to test implementation.
13 #include "../src/format.cc"
14 #include "fmt/printf.h"
15
16 #include <algorithm>
17 #include <cstring>
18
19 #include "gmock.h"
20 #include "gtest-extra.h"
21 #include "util.h"
22
23 #undef max
24
25 using fmt::internal::bigint;
26 using fmt::internal::fp;
27 using fmt::internal::max_value;
28
29 static_assert(!std::is_copy_constructible<bigint>::value, "");
30 static_assert(!std::is_copy_assignable<bigint>::value, "");
31
TEST(BigIntTest,Construct)32 TEST(BigIntTest, Construct) {
33 EXPECT_EQ("", fmt::format("{}", bigint()));
34 EXPECT_EQ("42", fmt::format("{}", bigint(0x42)));
35 EXPECT_EQ("123456789abcedf0", fmt::format("{}", bigint(0x123456789abcedf0)));
36 }
37
TEST(BigIntTest,Compare)38 TEST(BigIntTest, Compare) {
39 bigint n1(42);
40 bigint n2(42);
41 EXPECT_EQ(compare(n1, n2), 0);
42 n2 <<= 32;
43 EXPECT_LT(compare(n1, n2), 0);
44 bigint n3(43);
45 EXPECT_LT(compare(n1, n3), 0);
46 EXPECT_GT(compare(n3, n1), 0);
47 bigint n4(42 * 0x100000001);
48 EXPECT_LT(compare(n2, n4), 0);
49 EXPECT_GT(compare(n4, n2), 0);
50 }
51
TEST(BigIntTest,AddCompare)52 TEST(BigIntTest, AddCompare) {
53 EXPECT_LT(
54 add_compare(bigint(0xffffffff), bigint(0xffffffff), bigint(1) <<= 64), 0);
55 EXPECT_LT(add_compare(bigint(1) <<= 32, bigint(1), bigint(1) <<= 96), 0);
56 EXPECT_GT(add_compare(bigint(1) <<= 32, bigint(0), bigint(0xffffffff)), 0);
57 EXPECT_GT(add_compare(bigint(0), bigint(1) <<= 32, bigint(0xffffffff)), 0);
58 EXPECT_GT(add_compare(bigint(42), bigint(1), bigint(42)), 0);
59 EXPECT_GT(add_compare(bigint(0xffffffff), bigint(1), bigint(0xffffffff)), 0);
60 EXPECT_LT(add_compare(bigint(10), bigint(10), bigint(22)), 0);
61 EXPECT_LT(add_compare(bigint(0x100000010), bigint(0x100000010),
62 bigint(0x300000010)),
63 0);
64 EXPECT_GT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
65 bigint(0x300000000)),
66 0);
67 EXPECT_EQ(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
68 bigint(0x300000001)),
69 0);
70 EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
71 bigint(0x300000002)),
72 0);
73 EXPECT_LT(add_compare(bigint(0x1ffffffff), bigint(0x100000002),
74 bigint(0x300000003)),
75 0);
76 }
77
TEST(BigIntTest,ShiftLeft)78 TEST(BigIntTest, ShiftLeft) {
79 bigint n(0x42);
80 n <<= 0;
81 EXPECT_EQ("42", fmt::format("{}", n));
82 n <<= 1;
83 EXPECT_EQ("84", fmt::format("{}", n));
84 n <<= 25;
85 EXPECT_EQ("108000000", fmt::format("{}", n));
86 }
87
TEST(BigIntTest,Multiply)88 TEST(BigIntTest, Multiply) {
89 bigint n(0x42);
90 EXPECT_THROW(n *= 0, assertion_failure);
91 n *= 1;
92 EXPECT_EQ("42", fmt::format("{}", n));
93 n *= 2;
94 EXPECT_EQ("84", fmt::format("{}", n));
95 n *= 0x12345678;
96 EXPECT_EQ("962fc95e0", fmt::format("{}", n));
97 bigint bigmax(max_value<uint32_t>());
98 bigmax *= max_value<uint32_t>();
99 EXPECT_EQ("fffffffe00000001", fmt::format("{}", bigmax));
100 bigmax.assign(max_value<uint64_t>());
101 bigmax *= max_value<uint64_t>();
102 EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", bigmax));
103 }
104
TEST(BigIntTest,Accumulator)105 TEST(BigIntTest, Accumulator) {
106 fmt::internal::accumulator acc;
107 EXPECT_EQ(acc.lower, 0);
108 EXPECT_EQ(acc.upper, 0);
109 acc.upper = 12;
110 acc.lower = 34;
111 EXPECT_EQ(static_cast<uint32_t>(acc), 34);
112 acc += 56;
113 EXPECT_EQ(acc.lower, 90);
114 acc += fmt::internal::max_value<uint64_t>();
115 EXPECT_EQ(acc.upper, 13);
116 EXPECT_EQ(acc.lower, 89);
117 acc >>= 32;
118 EXPECT_EQ(acc.upper, 0);
119 EXPECT_EQ(acc.lower, 13 * 0x100000000);
120 }
121
TEST(BigIntTest,Square)122 TEST(BigIntTest, Square) {
123 bigint n0(0);
124 n0.square();
125 EXPECT_EQ("0", fmt::format("{}", n0));
126 bigint n1(0x100);
127 n1.square();
128 EXPECT_EQ("10000", fmt::format("{}", n1));
129 bigint n2(0xfffffffff);
130 n2.square();
131 EXPECT_EQ("ffffffffe000000001", fmt::format("{}", n2));
132 bigint n3(max_value<uint64_t>());
133 n3.square();
134 EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", n3));
135 bigint n4;
136 n4.assign_pow10(10);
137 EXPECT_EQ("2540be400", fmt::format("{}", n4));
138 }
139
TEST(BigIntTest,DivModAssignZeroDivisor)140 TEST(BigIntTest, DivModAssignZeroDivisor) {
141 bigint zero(0);
142 EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure);
143 EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure);
144 }
145
TEST(BigIntTest,DivModAssignSelf)146 TEST(BigIntTest, DivModAssignSelf) {
147 bigint n(100);
148 EXPECT_THROW(n.divmod_assign(n), assertion_failure);
149 }
150
TEST(BigIntTest,DivModAssignUnaligned)151 TEST(BigIntTest, DivModAssignUnaligned) {
152 // (42 << 340) / pow(10, 100):
153 bigint n1(42);
154 n1 <<= 340;
155 bigint n2;
156 n2.assign_pow10(100);
157 int result = n1.divmod_assign(n2);
158 EXPECT_EQ(result, 9406);
159 EXPECT_EQ("10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96",
160 fmt::format("{}", n1));
161 }
162
TEST(BigIntTest,DivModAssign)163 TEST(BigIntTest, DivModAssign) {
164 // 100 / 10:
165 bigint n1(100);
166 int result = n1.divmod_assign(bigint(10));
167 EXPECT_EQ(result, 10);
168 EXPECT_EQ("0", fmt::format("{}", n1));
169 // pow(10, 100) / (42 << 320):
170 n1.assign_pow10(100);
171 result = n1.divmod_assign(bigint(42) <<= 320);
172 EXPECT_EQ(result, 111);
173 EXPECT_EQ("13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96",
174 fmt::format("{}", n1));
175 // 42 / 100:
176 bigint n2(42);
177 n1.assign_pow10(2);
178 result = n2.divmod_assign(n1);
179 EXPECT_EQ(result, 0);
180 EXPECT_EQ("2a", fmt::format("{}", n2));
181 }
182
run_double_tests()183 template <bool is_iec559> void run_double_tests() {
184 fmt::print("warning: double is not IEC559, skipping FP tests\n");
185 }
186
run_double_tests()187 template <> void run_double_tests<true>() {
188 // Construct from double.
189 EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52));
190
191 // Compute boundaries:
192 fp value;
193 // Normalized & not power of 2 - equidistant boundaries:
194 auto b = value.assign_with_boundaries(1.23);
195 EXPECT_EQ(value, fp(0x0013ae147ae147ae, -52));
196 EXPECT_EQ(b.lower, 0x9d70a3d70a3d6c00);
197 EXPECT_EQ(b.upper, 0x9d70a3d70a3d7400);
198 // Normalized power of 2 - lower boundary is closer:
199 b = value.assign_with_boundaries(1.9807040628566084e+28); // 2**94
200 EXPECT_EQ(value, fp(0x0010000000000000, 42));
201 EXPECT_EQ(b.lower, 0x7ffffffffffffe00);
202 EXPECT_EQ(b.upper, 0x8000000000000400);
203 // Smallest normalized double - equidistant boundaries:
204 b = value.assign_with_boundaries(2.2250738585072014e-308);
205 EXPECT_EQ(value, fp(0x0010000000000000, -1074));
206 EXPECT_EQ(b.lower, 0x7ffffffffffffc00);
207 EXPECT_EQ(b.upper, 0x8000000000000400);
208 // Subnormal - equidistant boundaries:
209 b = value.assign_with_boundaries(4.9406564584124654e-324);
210 EXPECT_EQ(value, fp(0x0000000000000001, -1074));
211 EXPECT_EQ(b.lower, 0x4000000000000000);
212 EXPECT_EQ(b.upper, 0xc000000000000000);
213 }
214
TEST(FPTest,DoubleTests)215 TEST(FPTest, DoubleTests) {
216 run_double_tests<std::numeric_limits<double>::is_iec559>();
217 }
218
TEST(FPTest,Normalize)219 TEST(FPTest, Normalize) {
220 const auto v = fp(0xbeef, 42);
221 auto normalized = normalize(v);
222 EXPECT_EQ(0xbeef000000000000, normalized.f);
223 EXPECT_EQ(-6, normalized.e);
224 }
225
TEST(FPTest,ComputeFloatBoundaries)226 TEST(FPTest, ComputeFloatBoundaries) {
227 struct {
228 double x, lower, upper;
229 } tests[] = {
230 // regular
231 {1.5f, 1.4999999403953552, 1.5000000596046448},
232 // boundary
233 {1.0f, 0.9999999701976776, 1.0000000596046448},
234 // min normal
235 {1.1754944e-38f, 1.1754942807573643e-38, 1.1754944208872107e-38},
236 // max subnormal
237 {1.1754942e-38f, 1.1754941406275179e-38, 1.1754942807573643e-38},
238 // min subnormal
239 {1e-45f, 7.006492321624085e-46, 2.1019476964872256e-45},
240 };
241 for (auto test : tests) {
242 fp vlower = normalize(fp(test.lower));
243 fp vupper = normalize(fp(test.upper));
244 vlower.f >>= vupper.e - vlower.e;
245 vlower.e = vupper.e;
246 fp value;
247 auto b = value.assign_float_with_boundaries(test.x);
248 EXPECT_EQ(vlower.f, b.lower);
249 EXPECT_EQ(vupper.f, b.upper);
250 }
251 }
252
TEST(FPTest,Multiply)253 TEST(FPTest, Multiply) {
254 auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
255 EXPECT_EQ(v.f, 123u * 56u);
256 EXPECT_EQ(v.e, 4 + 7 + 64);
257 v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
258 EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
259 EXPECT_EQ(v.e, 4 + 8 + 64);
260 }
261
TEST(FPTest,GetCachedPower)262 TEST(FPTest, GetCachedPower) {
263 typedef std::numeric_limits<double> limits;
264 for (auto exp = limits::min_exponent; exp <= limits::max_exponent; ++exp) {
265 int dec_exp = 0;
266 auto fp = fmt::internal::get_cached_power(exp, dec_exp);
267 EXPECT_LE(exp, fp.e);
268 int dec_exp_step = 8;
269 EXPECT_LE(fp.e, exp + dec_exp_step * log2(10));
270 EXPECT_DOUBLE_EQ(pow(10, dec_exp), ldexp(static_cast<double>(fp.f), fp.e));
271 }
272 }
273
TEST(FPTest,GetRoundDirection)274 TEST(FPTest, GetRoundDirection) {
275 using fmt::internal::get_round_direction;
276 EXPECT_EQ(fmt::internal::down, get_round_direction(100, 50, 0));
277 EXPECT_EQ(fmt::internal::up, get_round_direction(100, 51, 0));
278 EXPECT_EQ(fmt::internal::down, get_round_direction(100, 40, 10));
279 EXPECT_EQ(fmt::internal::up, get_round_direction(100, 60, 10));
280 for (int i = 41; i < 60; ++i)
281 EXPECT_EQ(fmt::internal::unknown, get_round_direction(100, i, 10));
282 uint64_t max = max_value<uint64_t>();
283 EXPECT_THROW(get_round_direction(100, 100, 0), assertion_failure);
284 EXPECT_THROW(get_round_direction(100, 0, 100), assertion_failure);
285 EXPECT_THROW(get_round_direction(100, 0, 50), assertion_failure);
286 // Check that remainder + error doesn't overflow.
287 EXPECT_EQ(fmt::internal::up, get_round_direction(max, max - 1, 2));
288 // Check that 2 * (remainder + error) doesn't overflow.
289 EXPECT_EQ(fmt::internal::unknown,
290 get_round_direction(max, max / 2 + 1, max / 2));
291 // Check that remainder - error doesn't overflow.
292 EXPECT_EQ(fmt::internal::unknown, get_round_direction(100, 40, 41));
293 // Check that 2 * (remainder - error) doesn't overflow.
294 EXPECT_EQ(fmt::internal::up, get_round_direction(max, max - 1, 1));
295 }
296
TEST(FPTest,FixedHandler)297 TEST(FPTest, FixedHandler) {
298 struct handler : fmt::internal::fixed_handler {
299 char buffer[10];
300 handler(int prec = 0) : fmt::internal::fixed_handler() {
301 buf = buffer;
302 precision = prec;
303 }
304 };
305 int exp = 0;
306 handler().on_digit('0', 100, 99, 0, exp, false);
307 EXPECT_THROW(handler().on_digit('0', 100, 100, 0, exp, false),
308 assertion_failure);
309 namespace digits = fmt::internal::digits;
310 EXPECT_EQ(handler(1).on_digit('0', 100, 10, 10, exp, false), digits::done);
311 // Check that divisor - error doesn't overflow.
312 EXPECT_EQ(handler(1).on_digit('0', 100, 10, 101, exp, false), digits::error);
313 // Check that 2 * error doesn't overflow.
314 uint64_t max = max_value<uint64_t>();
315 EXPECT_EQ(handler(1).on_digit('0', max, 10, max - 1, exp, false),
316 digits::error);
317 }
318
TEST(FPTest,GrisuFormatCompilesWithNonIEEEDouble)319 TEST(FPTest, GrisuFormatCompilesWithNonIEEEDouble) {
320 fmt::memory_buffer buf;
321 format_float(0.42, -1, fmt::internal::float_specs(), buf);
322 }
323
324 template <typename T> struct value_extractor {
operator ()value_extractor325 T operator()(T value) { return value; }
326
operator ()value_extractor327 template <typename U> FMT_NORETURN T operator()(U) {
328 throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
329 }
330
331 #ifdef __apple_build_version__
332 // Apple Clang does not define typeid for __int128_t and __uint128_t.
operator ()value_extractor333 FMT_NORETURN T operator()(__int128_t) {
334 throw std::runtime_error(fmt::format("invalid type {}", "__int128_t"));
335 }
336
operator ()value_extractor337 FMT_NORETURN T operator()(__uint128_t) {
338 throw std::runtime_error(fmt::format("invalid type {}", "__uint128_t"));
339 }
340 #endif
341 };
342
TEST(FormatTest,ArgConverter)343 TEST(FormatTest, ArgConverter) {
344 long long value = max_value<long long>();
345 auto arg = fmt::internal::make_arg<fmt::format_context>(value);
346 fmt::visit_format_arg(
347 fmt::internal::arg_converter<long long, fmt::format_context>(arg, 'd'),
348 arg);
349 EXPECT_EQ(value, fmt::visit_format_arg(value_extractor<long long>(), arg));
350 }
351
TEST(FormatTest,FormatNegativeNaN)352 TEST(FormatTest, FormatNegativeNaN) {
353 double nan = std::numeric_limits<double>::quiet_NaN();
354 if (std::signbit(-nan))
355 EXPECT_EQ("-nan", fmt::format("{}", -nan));
356 else
357 fmt::print("Warning: compiler doesn't handle negative NaN correctly");
358 }
359
TEST(FormatTest,StrError)360 TEST(FormatTest, StrError) {
361 char* message = nullptr;
362 char buffer[BUFFER_SIZE];
363 EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = nullptr, 0),
364 "invalid buffer");
365 EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = buffer, 0),
366 "invalid buffer");
367 buffer[0] = 'x';
368 #if defined(_GNU_SOURCE) && !defined(__COVERITY__)
369 // Use invalid error code to make sure that safe_strerror returns an error
370 // message in the buffer rather than a pointer to a static string.
371 int error_code = -1;
372 #else
373 int error_code = EDOM;
374 #endif
375
376 int result =
377 fmt::internal::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
378 EXPECT_EQ(result, 0);
379 std::size_t message_size = std::strlen(message);
380 EXPECT_GE(BUFFER_SIZE - 1u, message_size);
381 EXPECT_EQ(get_system_error(error_code), message);
382
383 // safe_strerror never uses buffer on MinGW.
384 #if !defined(__MINGW32__) && !defined(__sun)
385 result =
386 fmt::internal::safe_strerror(error_code, message = buffer, message_size);
387 EXPECT_EQ(ERANGE, result);
388 result = fmt::internal::safe_strerror(error_code, message = buffer, 1);
389 EXPECT_EQ(buffer, message); // Message should point to buffer.
390 EXPECT_EQ(ERANGE, result);
391 EXPECT_STREQ("", message);
392 #endif
393 }
394
TEST(FormatTest,FormatErrorCode)395 TEST(FormatTest, FormatErrorCode) {
396 std::string msg = "error 42", sep = ": ";
397 {
398 fmt::memory_buffer buffer;
399 format_to(buffer, "garbage");
400 fmt::internal::format_error_code(buffer, 42, "test");
401 EXPECT_EQ("test: " + msg, to_string(buffer));
402 }
403 {
404 fmt::memory_buffer buffer;
405 std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size() + 1,
406 'x');
407 fmt::internal::format_error_code(buffer, 42, prefix);
408 EXPECT_EQ(msg, to_string(buffer));
409 }
410 int codes[] = {42, -1};
411 for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
412 // Test maximum buffer size.
413 msg = fmt::format("error {}", codes[i]);
414 fmt::memory_buffer buffer;
415 std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
416 fmt::internal::format_error_code(buffer, codes[i], prefix);
417 EXPECT_EQ(prefix + sep + msg, to_string(buffer));
418 std::size_t size = fmt::inline_buffer_size;
419 EXPECT_EQ(size, buffer.size());
420 buffer.resize(0);
421 // Test with a message that doesn't fit into the buffer.
422 prefix += 'x';
423 fmt::internal::format_error_code(buffer, codes[i], prefix);
424 EXPECT_EQ(msg, to_string(buffer));
425 }
426 }
427
TEST(FormatTest,CountCodePoints)428 TEST(FormatTest, CountCodePoints) {
429 EXPECT_EQ(4, fmt::internal::count_code_points(fmt::u8string_view("ёжик")));
430 }
431
432 // Tests fmt::internal::count_digits for integer type Int.
test_count_digits()433 template <typename Int> void test_count_digits() {
434 for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::internal::count_digits(i));
435 for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) {
436 n *= 10;
437 EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
438 EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
439 }
440 }
441
TEST(UtilTest,CountDigits)442 TEST(UtilTest, CountDigits) {
443 test_count_digits<uint32_t>();
444 test_count_digits<uint64_t>();
445 }
446
TEST(UtilTest,WriteUIntPtr)447 TEST(UtilTest, WriteUIntPtr) {
448 fmt::memory_buffer buf;
449 fmt::internal::writer writer(buf);
450 writer.write_pointer(fmt::internal::fallback_uintptr(
451 reinterpret_cast<void*>(0xface)),
452 nullptr);
453 EXPECT_EQ("0xface", to_string(buf));
454 }
455