Gamp v0.0.8
Gamp: Graphics, Audio, Multimedia and Processing
Loading...
Searching...
No Matches
test_stringfmt_format.cpp
Go to the documentation of this file.
1/**
2 * Author: Sven Gothel <sgothel@jausoft.com>
3 * Copyright (c) 2024 Gothel Software e.K.
4 *
5 * ***
6 *
7 * SPDX-License-Identifier: MIT
8 *
9 * This Source Code Form is subject to the terms of the MIT License
10 * If a copy of the MIT was not distributed with this
11 * file, You can obtain one at https://opensource.org/license/mit/.
12 *
13 */
14#include <sys/types.h>
15#include <cassert>
16#include <cinttypes>
17#include <cstdint>
18#include <cstdio>
19#include <cstring>
20#include <iostream>
21#include <string_view>
22
23#include <jau/basic_types.hpp>
24#include <jau/cpp_lang_util.hpp>
25#include <jau/cpp_pragma.hpp>
26#include <jau/float_types.hpp>
27#include <jau/int_types.hpp>
28#include <jau/string_cfmt.hpp>
29#include <jau/string_literal.hpp>
30#include <jau/string_util.hpp>
31#include <jau/test/catch2_ext.hpp>
32#include <jau/type_concepts.hpp>
33#include <jau/type_traits_queries.hpp>
34
35#ifdef HAS_STD_FORMAT
36 #include <format>
37#endif
38
39using namespace std::literals;
40
41using namespace jau::float_literals;
42
43using namespace jau::int_literals;
44
45TEST_CASE("parse: width precision from format", "[jau][std::string][jau::cfmt]") {
46 using namespace jau::cfmt;
47
48 //
49 // Single feature: Width / Precision
50 //
51 {
52 std::string s;
53 jau::cfmt::Result r = jau::cfmt::formatR(s,"%" PRIi64, (int64_t)1);
54 std::cerr << "FormatResult " << r << "\n";
55 REQUIRE( true == r.success());
56 REQUIRE( 1 == r.argumentCount());
57 REQUIRE( flags_t::none == r.opts().flags);
58 REQUIRE( false == r.opts().width_set);
59 REQUIRE( 0 == r.opts().width);
60 REQUIRE( false == r.opts().precision_set);
61 REQUIRE( 0 == r.opts().precision);
62 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
63 }
64 {
65 std::string s;
66 jau::cfmt::Result r = jau::cfmt::formatR(s,"%23" PRIi64, (int64_t)1);
67 std::cerr << "FormatResult " << r << "\n";
68 REQUIRE( true == r.success());
69 REQUIRE( 1 == r.argumentCount());
70 REQUIRE( flags_t::none == r.opts().flags);
71 REQUIRE( true == r.opts().width_set);
72 REQUIRE( 23 == r.opts().width);
73 REQUIRE( false == r.opts().precision_set);
74 REQUIRE( 0 == r.opts().precision);
75 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
76 }
77 {
78 std::string s;
79 jau::cfmt::Result r = jau::cfmt::formatR(s,"%.12" PRIi64, (int64_t)1);
80 std::cerr << "FormatResult " << r << "\n";
81 REQUIRE( true == r.success());
82 REQUIRE( 1 == r.argumentCount());
83 REQUIRE( flags_t::none == r.opts().flags);
84 REQUIRE( false == r.opts().width_set);
85 REQUIRE( 0 == r.opts().width);
86 REQUIRE( true == r.opts().precision_set);
87 REQUIRE( 12 == r.opts().precision);
88 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
89 }
90 {
91 std::string s;
92 jau::cfmt::Result r = jau::cfmt::formatR(s,"%23.12" PRIi64, (int64_t)1);
93 std::cerr << "FormatResult " << r << "\n";
94 REQUIRE( true == r.success());
95 REQUIRE( 1 == r.argumentCount());
96 REQUIRE( flags_t::none == r.opts().flags);
97 REQUIRE( true == r.opts().width_set);
98 REQUIRE( 23 == r.opts().width);
99 REQUIRE( true == r.opts().precision_set);
100 REQUIRE( 12 == r.opts().precision);
101 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
102 }
103 {
104 std::string s;
105 jau::cfmt::Result r = jau::cfmt::formatR(s,"%#-+0 23.12" PRIi64, (int64_t)1);
106 std::cerr << "FormatResult " << r << "\n";
107 REQUIRE( true == r.success());
108 REQUIRE( 1 == r.argumentCount());
109 REQUIRE( ( flags_t::left | flags_t::plus ) == r.opts().flags);
110 REQUIRE( true == r.opts().width_set);
111 REQUIRE( 23 == r.opts().width);
112 REQUIRE( true == r.opts().precision_set);
113 REQUIRE( 12 == r.opts().precision);
114 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
115 }
116}
117
118TEST_CASE("parse: width precision from arg", "[jau][std::string][jau::cfmt]") {
119 using namespace jau::cfmt;
120
121 {
122 jau_format_check("%*" PRIi64, 21, (int64_t)1);
123 jau_format_checkLine("%*" PRIi64, 21, (int64_t)1);
124 std::string s;
125 jau::cfmt::Result r = jau::cfmt::formatR(s,"%*" PRIi64, 21, (int64_t)1);
126 std::cerr << "FormatResult " << r << "\n";
127 REQUIRE( true == r.success());
128 REQUIRE( 2 == r.argumentCount());
129 REQUIRE( flags_t::none == r.opts().flags);
130 REQUIRE( true == r.opts().width_set);
131 REQUIRE( 21 == r.opts().width);
132 REQUIRE( false == r.opts().precision_set);
133 REQUIRE( 0 == r.opts().precision);
134 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
135 }
136 {
137 std::string s;
138 jau::cfmt::Result r = jau::cfmt::formatR(s,"%.*" PRIi64, 12, (int64_t)1);
139 std::cerr << "FormatResult " << r << "\n";
140 REQUIRE( true == r.success());
141 REQUIRE( 2 == r.argumentCount());
142 REQUIRE( flags_t::none == r.opts().flags);
143 REQUIRE( false == r.opts().width_set);
144 REQUIRE( 0 == r.opts().width);
145 REQUIRE( true == r.opts().precision_set);
146 REQUIRE( 12 == r.opts().precision);
147 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
148 }
149 {
150 std::string s;
151 jau::cfmt::Result r = jau::cfmt::formatR(s,"%*.*" PRIi64, 23, 12, (int64_t)1);
152 std::cerr << "FormatResult " << r << "\n";
153 REQUIRE( true == r.success());
154 REQUIRE( 3 == r.argumentCount());
155 REQUIRE( flags_t::none == r.opts().flags);
156 REQUIRE( true == r.opts().width_set);
157 REQUIRE( 23 == r.opts().width);
158 REQUIRE( true == r.opts().precision_set);
159 REQUIRE( 12 == r.opts().precision);
160 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
161 }
162
163 {
164 std::string s;
165 jau::cfmt::Result r = jau::cfmt::formatR(s,"%-*.12" PRIi64, 23, (int64_t)1);
166 std::cerr << "FormatResult " << r << "\n";
167 REQUIRE( true == r.success());
168 REQUIRE( 2 == r.argumentCount());
169 REQUIRE( flags_t::left == r.opts().flags);
170 REQUIRE( true == r.opts().width_set);
171 REQUIRE( 23 == r.opts().width);
172 REQUIRE( true == r.opts().precision_set);
173 REQUIRE( 12 == r.opts().precision);
174 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
175 }
176 {
177 std::string s;
178 jau::cfmt::Result r = jau::cfmt::formatR(s,"%+.*" PRIi64, 12, (int64_t)1);
179 std::cerr << "FormatResult " << r << "\n";
180 REQUIRE( true == r.success());
181 REQUIRE( 2 == r.argumentCount());
182 REQUIRE( flags_t::plus == r.opts().flags);
183 REQUIRE( false == r.opts().width_set);
184 REQUIRE( 0 == r.opts().width);
185 REQUIRE( true == r.opts().precision_set);
186 REQUIRE( 12 == r.opts().precision);
187 REQUIRE( jau::cfmt::plength_t::l == r.opts().length_mod);
188 }
189}
190
191template <typename... Args>
192static void checkFormat(int line, const char *fmt, const Args &...args) {
193 std::string exp = jau::unsafe::format_string(fmt, args...);
194 // std::string has = jau::format_string(fmt, args...);
195 std::string has;
196 jau::cfmt::Result r = jau::cfmt::formatR(has, fmt, args...);
197 std::cerr << "FormatResult @ " << line << ": " << r << "\n";
198 std::cerr << "FormatResult @ " << line << ": exp `" << exp << "`, has `" << has << "`\n\n";
199 CHECK( true == r.success());
200 CHECK( sizeof...(args) == r.argumentCount());
201 CHECK(exp == has);
202}
203
204class SomeClass {
205 public:
206 std::string toString() const { return "SomeClass toString"; }
207};
208enum class game_t : uint16_t {
209 none,
210 chess,
211 pacman,
212 mrdo
213};
214JAU_MAKE_ENUM_STRING(game_t, chess, pacman, mrdo); // NOLINT
215
216enum class plainenum_t : uint16_t {
217 none,
218 lala,
219 lili
220};
221
222TEST_CASE("single_conversion", "[jau][std::string][jau::cfmt]") {
223 // type conversion
224 int32_t i32 = -1234;
225 int32_t i32_u = 1234;
226 uint32_t u32 = 1234;
227 float f32 = 123.45f; // 42.14f;
228 double f64 = 123.45; // 42.1456;
229 void *p1a = (void *)0xaabbccdd_u64; // NOLINT
230 void *p1b = (void *)0x11223344aabbccdd_u64; // NOLINT
231 void *p2a = (void *)0x112233aabbccdd_u64; // NOLINT
232 void *p2b = (void *)0xaabbcc_u64; // NOLINT
233 void *p3a = (void *)0x112233aabbccdd_u64; // NOLINT
234 void *p3b = (void *)0xaabbcc_u64; // NOLINT
235 const char sl1[] = "Hallo";
236 std::string s2 = "World";
237 std::string_view s2sv = s2;
238 const char *s2p = s2.c_str();
239
240 {
241 double value = 123.45;
242 const int expval = std::ilogb(value);
243 const double frac = value / std::scalbn(1.0, expval);
244 const uint64_t significand = jau::significand_raw(value);
245 fprintf(stderr, "JAU:10 v %f = %f * 2^%d -> 0x%0" PRIx64 "p%d\n", value, frac, expval, significand, expval);
246
247 const int32_t expval2 = jau::exponent_unbiased(value);
248 fprintf(stderr, "JAU:11 v %f = %f * 2^%d -> 0x%0" PRIx64 "p%d\n", value, frac, expval2, significand, expval2);
249 }
250 {
251 float value = 123.45f;
252 const int expval = std::ilogb(value);
253 const double frac = value / std::scalbn(1.0, expval);
254 const uint32_t significand = jau::significand_raw(value);
255 fprintf(stderr, "JAU:20 v %f = %f * 2^%d -> 0x%0" PRIx32 "p%d\n", value, frac, expval, significand, expval);
256
257 const int32_t expval2 = jau::exponent_unbiased(value);
258 fprintf(stderr, "JAU:21 v %f = %f * 2^%d -> 0x%0" PRIx32 "p%d\n", value, frac, expval2, significand, expval2);
259 }
260 {
261 float ivalue = 123.45f;
262 double value = ivalue;
263 const int expval = std::ilogb(value);
264 const double frac = value / std::scalbn(1.0, expval);
265 const uint64_t significand = jau::significand_raw(value) >> (32-4);
266 fprintf(stderr, "JAU:30 v %f = %f * 2^%d -> 0x%0" PRIx64 "p%d\n", value, frac, expval, significand, expval);
267
268 const int32_t expval2 = jau::exponent_unbiased(value);
269 fprintf(stderr, "JAU:31 v %f = %f * 2^%d -> 0x%0" PRIx64 "p%d\n", value, frac, expval2, significand, expval2);
270 }
271 checkFormat(__LINE__, "%%");
272
273 checkFormat(__LINE__, "%c", 'Z');
274 checkFormat(__LINE__, "%s", "Hello World");
275 checkFormat(__LINE__, "%s", sl1);
276 {
277 // impossible for vsnprintf (via jau::unsafe::format_string)
278 CHECK( 1 == jau::cfmt::check("%s", s2));
279 CHECK( "World" == jau::format_string("%s", s2));
280 CHECK( 1 == jau::cfmt::check("%s", s2sv));
281 CHECK( "World" == jau::format_string("%s", s2sv));
282 }
283 {
284 // jau_format_checkLine("%s", (int)0);
285 CHECK( -1 == jau::cfmt::check("%s", (int)0));
286 }
287 {
288 const char *cstr0 = nullptr;
289 const char *cstr1 = "Hello World";
290 jau_format_checkLine("%s", cstr0);
291 CHECK( "(null)" == jau::format_string("%s", cstr0));
292 CHECK( "Hello World" == jau::format_string("%s", cstr1));
293 }
294 {
295 const void *handle = (void *)0x12345678;
296 const void *nil = nullptr;
297 jau_format_checkLine("%p", handle);
298 CHECK( "0x12345678" == jau::format_string("%p", handle));
299 CHECK( "(nil)" == jau::format_string("%p", nil));
300 jau_format_checkLine("%#p", handle);
301 CHECK( "0x12345678" == jau::format_string("%#p", handle));
302 CHECK( "(nil)" == jau::format_string("%#p", nil));
303
304 // only `char*` for string allowed
305 CHECK( -1 == jau::cfmt::check("%s", handle));
306 CHECK( true == jau::format_string("%s", handle).starts_with("<E#1"));
307 CHECK( true == jau::format_string("%s", nil).starts_with("<E#1"));
308 }
309 {
310 CHECK("SomeClass toString" == jau::to_string(SomeClass()));
311 jau_format_checkLine("%s", SomeClass());
312 CHECK( "SomeClass toString" == jau::format_string("%s", SomeClass()));
313
314 CHECK("chess" == jau::to_string(game_t::chess));
315 CHECK("pacman" == jau::to_string(game_t::pacman));
316 jau_format_checkLine("%s", game_t::chess);
317 CHECK( "chess" == jau::format_string("%s", game_t::chess));
318 CHECK( "pacman" == jau::format_string("%s", game_t::pacman));
319
320 CHECK("lala" != jau::to_string(plainenum_t::lala)); // no to_string available
321 CHECK( -1 == jau::cfmt::check("%s", plainenum_t::lala)); // no to_string available
322
323 CHECK("little" == jau::to_string(jau::lb_endian_t::little));
324 jau_format_checkLine("%s", jau::lb_endian_t::little);
325 CHECK( "little" == jau::format_string("%s", jau::lb_endian_t::little));
326 }
327 checkFormat(__LINE__, "%p", &i32);
328 checkFormat(__LINE__, "p1a %p %0p", p1a, p1a);
329 checkFormat(__LINE__, "p1b %p %0p", p1b, p1b);
330 checkFormat(__LINE__, "p2a %p %0p", p2a, p2a);
331 checkFormat(__LINE__, "p2b %p %0p", p2b, p2b);
332 checkFormat(__LINE__, "p3a %p %0p", p3a, p3a);
333 checkFormat(__LINE__, "p3b %p %0p", p3b, p3b);
334 checkFormat(__LINE__, "p3b %p %0p", &i32_u, &i32_u);
335 checkFormat(__LINE__, "p3b %p %0p", &sl1, &sl1);
336 checkFormat(__LINE__, "p3b %p %0p", s2p, s2p);
337 checkFormat(__LINE__, "%p", (void *)nullptr);
338 checkFormat(__LINE__, "%s", (char *)nullptr);
339
340 checkFormat(__LINE__, "%d", i32);
341
342 checkFormat(__LINE__, "%o", u32);
343 checkFormat(__LINE__, "%x", u32);
344 checkFormat(__LINE__, "%X", u32);
345 checkFormat(__LINE__, "%u", u32);
346 checkFormat(__LINE__, "%o", i32_u);
347 checkFormat(__LINE__, "%x", i32_u);
348 checkFormat(__LINE__, "%X", i32_u);
349 checkFormat(__LINE__, "%u", i32_u);
350
351 checkFormat(__LINE__, "%f", f64);
352 checkFormat(__LINE__, "%e", f64);
353 checkFormat(__LINE__, "%E", f64);
354 checkFormat(__LINE__, "%a", f64);
355 checkFormat(__LINE__, "%A", f64);
356 // checkFormat(__LINE__, "%g", f64);
357 // checkFormat(__LINE__, "%G", f64);
358
359 checkFormat(__LINE__, "%f", f32);
360 checkFormat(__LINE__, "%e", f32);
361 checkFormat(__LINE__, "%E", f32);
362 checkFormat(__LINE__, "%a", f32);
363 checkFormat(__LINE__, "%A", f32);
364 // checkFormat(__LINE__, "%g", f32);
365 // checkFormat(__LINE__, "%G", f32);
366
367 checkFormat(__LINE__, "%dZZZ", i32);
368 checkFormat(__LINE__, "%dZZ", i32);
369 checkFormat(__LINE__, "%dZ", i32);
370 checkFormat(__LINE__, "Z%dZ Z%dZ", i32, i32);
371 checkFormat(__LINE__, "Z%-6dZ Z%6dZ", i32, i32);
372
373 checkFormat(__LINE__, "%#020x", 305441741);
374 checkFormat(__LINE__, "%zd", 2147483647L);
375
376 static_assert(0 < jau::cfmt::checkLine("%zd", 2147483647UL)); // failed intentionally unsigned -> signed
377 checkFormat(__LINE__, "%zu", 2147483647UL);
378
379 static_assert(0 == jau::cfmt::checkLine("%s", (const char*)"Test"));
380 static_assert(0 == jau::cfmt::checkLine("%s", "Test"));
381 checkFormat(__LINE__, "%s", "Test");
382 {
383 const char *str = nullptr;
384 size_t str_len = 2;
385 const char limiter = '3';
386 const char *limiter_pos = nullptr;
387 char *endptr = nullptr;
388
389 jau_format_check("Value end not '%c' @ idx %zd, %p != %p, in: %p '%s' len %zu", limiter, endptr - str, endptr, limiter_pos, str, str, str_len);
390 jau_format_checkLine("Value end not '%c' @ idx %zd, %p != %p, in: %p '%s' len %zu", limiter, endptr - str, endptr, limiter_pos, str, str, str_len);
391 }
392 // bool
393 {
394 jau_format_check("%d", (bool)true);
395 jau_format_checkLine("%d", (bool)true);
396 jau_format_check("%u", (bool)true);
397 jau_format_checkLine("%u", (bool)true);
398 jau_format_check("%s", (bool)true);
399 jau_format_checkLine("%s", (bool)true);
400 CHECK("1" == jau::format_string("%d", (bool)true));
401 CHECK("0" == jau::format_string("%d", (bool)false));
402 CHECK("1" == jau::format_string("%u", (bool)true));
403 CHECK("0" == jau::format_string("%u", (bool)false));
404 CHECK("true" == jau::format_string("%s", (bool)true));
405 CHECK("false" == jau::format_string("%s", (bool)false));
406 }
407
408 // enums
409 {
410 enum enum1_unsigned_t { jau1_alpha, jau1_beta, jau1_gamma }; ///< unsigned
411 enum1_unsigned_t e1_u = jau1_alpha;
412
413 enum enum2_signed_t { jau2_alpha=-1, jau_beta, jau_gamma }; ///< signed
414 enum2_signed_t e2_s = jau2_alpha;
415
416 enum class enum3_signed_t { alpha=-1, beta, gamma }; ///< signed
417 enum3_signed_t e3_s = enum3_signed_t::alpha;
418
419 typedef enum { ///< unsigned
420 jau_CAP_CLEAR=0,
421 jau_CAP_SET=1
422 } enum4_unsigned_t;
423 enum4_unsigned_t e4_u = jau_CAP_CLEAR;
424
425 static_assert(true == std::is_enum_v<decltype(e1_u)>);
426 static_assert(true == std::is_unsigned_v<std::underlying_type_t<decltype(e1_u)>>);
427
428 static_assert(true == std::is_enum_v<decltype(e2_s)>);
429 static_assert(true == std::is_signed_v<std::underlying_type_t<decltype(e2_s)>>);
430
431 static_assert(true == std::is_enum_v<decltype(e3_s)>);
432 static_assert(true == std::is_signed_v<std::underlying_type_t<decltype(e3_s)>>);
433
434 static_assert(true == std::is_enum_v<decltype(e4_u)>);
435 static_assert(true == std::is_unsigned_v<std::underlying_type_t<decltype(e4_u)>>);
436
437 jau_format_string("Enum %u, %d, %d, %u\n", e1_u, e2_s, e3_s, e4_u);
438 jau_format_checkLine("%u, %d, %d, %u\n", e1_u, e2_s, e3_s, e4_u);
439
440 static_assert(4 == jau::cfmt::check("%u, %d, %d, %u\n", e1_u, e2_s, e3_s, e4_u));
441 static_assert(0 == jau::cfmt::checkLine("%u, %u, %d, %u\n", e1_u, e2_s, e3_s, e4_u));
442
443 static_assert(0 == jau::cfmt::checkLine("%u\n", e1_u)); // unsigned -> unsigned OK
444 static_assert(0 < jau::cfmt::checkLine("%d\n", e1_u)); // unsigned -> signed ERROR
445 static_assert(0 == jau::cfmt::checkLine("%u\n", e2_s)); // signed -> unsigned OK
446 }
447}
448
449TEST_CASE("integral_conversion", "[jau][std::string][jau::cfmt]") {
450 static constexpr const char *format_check_exp1 = "format_check: -1, 2, -3, 4, -5, 6, -7, 8, -9, 10";
451 static constexpr const char *format_check_exp2 = "format_check: -1, 02, -03, 0004, -0005, 000006, -000007, 00000008, -00000009, 0000000010";
452 char i1=-1;
453 unsigned char i2=2;
454
455 short i3=-3;
456 unsigned short i4=4;
457
458 int i5=-5;
459 unsigned int i6=6;
460
461 long i7=-7;
462 unsigned long i8=8;
463
464 ssize_t i9 = -9;
465 size_t i10 = 10;
466
467 jau_format_check("format_check: %hhd, %hhu, %hd, %hu, %d, %u, %ld, %lu, %zd, %zu", i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);
468 CHECK(format_check_exp1 == jau::format_string("format_check: %hhd, %hhu, %hd, %hu, %d, %u, %ld, %lu, %zd, %zu", i1, i2, i3, i4, i5, i6, i7, i8, i9, i10));
469
470 jau_format_check("format_check: %01hhd, %02hhu, %03hd, %04hu, %05d, %06u, %07ld, %08lu, %09zd, %010zu", i1, i2, i3, i4, i5, i6, i7, i8, i9, i10);
471 CHECK(format_check_exp2 == jau::format_string("format_check: %01hhd, %02hhu, %03hd, %04hu, %05d, %06u, %07ld, %08lu, %09zd, %010zu", i1, i2, i3, i4, i5, i6, i7, i8, i9, i10));
472}
473
474TEST_CASE("thousands_flag", "[jau][std::string][jau::cfmt][flags]" ) {
475 //
476 // thousand flag ' or ,
477 //
478 jau_format_checkLine("%'d", 1);
479 jau_format_checkLine("%,d", 1);
480
481 CHECK("1" == jau::format_string("%'d", 1));
482 CHECK("10" == jau::format_string("%#'d", 10));
483 CHECK("100" == jau::format_string("%,d", 100));
484 CHECK("1'000" == jau::format_string("%#'d", 1000));
485 CHECK("1'000'000" == jau::format_string("%,d", 1000000));
486 CHECK("+1'000'000" == jau::format_string("%'+d", 1000000));
487 CHECK("+1'000'000" == jau::format_string("%#'+d", 1000000));
488 CHECK("-1'000'000" == jau::format_string("%,d", -1000000));
489 CHECK("-1'000'000" == jau::format_string("%#'d", -1000000));
490
491 CHECK("ff" == jau::format_string("%'x", 0xff_u32));
492 CHECK("0xff" == jau::format_string("%#'x", 0xff_u32));
493 CHECK("ffff" == jau::format_string("%,x", 0xffff_u32));
494 CHECK("0x1'ffff" == jau::format_string("%#'x", 0x1ffff_u32));
495 CHECK("1'ffff'ffff" == jau::format_string("%,lx", 0x1ffffffff_i64));
496 CHECK("0x1'ffff'ffff" == jau::format_string("%#'lx", 0x1ffffffff_u64));
497 // negative types not allowed for hex-conversion
498
499 // separator, space-padding
500 CHECK(" 876'543" == jau::format_string("%,8d", 876543));
501 CHECK("9'876'543" == jau::format_string("%,8d", 9876543));
502 CHECK("9'876'543" == jau::format_string("%,9d", 9876543));
503 CHECK(" 9'876'543" == jau::format_string("%,10d", 9876543));
504 CHECK(" 9'876'543" == jau::format_string("%,13d", 9876543));
505
506 CHECK("0xaffe" == jau::format_string("%#'x", 0xaffe_u32));
507 CHECK("0xaffe" == jau::format_string("%#'6x", 0xaffe_u32));
508 CHECK(" 0xaffe" == jau::format_string("%#'7x", 0xaffe_u32));
509 CHECK(" 0xaffe" == jau::format_string("%#'8x", 0xaffe_u32));
510 CHECK("0x1'affe" == jau::format_string("%#'7x", 0x1affe_u32));
511 CHECK(" 0x1'affe" == jau::format_string("%#'12x", 0x1affe_u32));
512
513 // separator, zero-padding
514 CHECK("'876'543" == jau::format_string("%,08d", 876543));
515 CHECK("9'876'543" == jau::format_string("%,08d", 9876543));
516 CHECK("9'876'543" == jau::format_string("%,09d", 9876543));
517 CHECK("09'876'543" == jau::format_string("%,010d", 9876543));
518 CHECK("0'009'876'543" == jau::format_string("%,013d", 9876543));
519
520 CHECK("0xaffe" == jau::format_string("%#'x", 0xaffe_u32));
521 CHECK("0xaffe" == jau::format_string("%#'06x", 0xaffe_u32));
522 CHECK("0x'affe" == jau::format_string("%#'07x", 0xaffe_u32));
523 CHECK("0x0'affe" == jau::format_string("%#'08x", 0xaffe_u32));
524 CHECK("0x1'affe" == jau::format_string("%#'07x", 0x1affe_u32));
525 CHECK("0x'0001'affe" == jau::format_string("%#'012x", 0x1affe_u32));
526}
527
528TEST_CASE("binary", "[jau][std::string][jau::cfmt][flags]" ) {
529 jau_format_checkLine("%b", 1_u32);
530
531 CHECK("0b1" == jau::format_string("%#b", 1_u32));
532 CHECK("0b1010111111111110" == jau::format_string("%#b", 0xaffe_u32));
533 CHECK("1011111011101111" == jau::format_string("%b", 0xbeef_u32));
534}
535
536TEST_CASE("space_flag", "[jau][std::string][jau::cfmt][flags]" ) {
537 std::string buffer;
538
539 buffer = jau::format_string("% d", 42);
540 CHECK(buffer == " 42");
541
542 buffer = jau::format_string("% d", -42);
543 CHECK(buffer == "-42");
544
545 buffer = jau::format_string("% 5d", 42);
546 CHECK(buffer == " 42");
547
548 buffer = jau::format_string("% 5d", -42);
549 CHECK(buffer == " -42"); // "- 42" == " -42"
550
551 buffer = jau::format_string("% 15d", 42);
552 CHECK(buffer == " 42");
553
554 buffer = jau::format_string("% 15d", -42);
555 CHECK(buffer == " -42");
556
557 buffer = jau::format_string("% 15d", -42);
558 CHECK(buffer == " -42");
559
560 buffer = jau::format_string("% 15.3f", -42.987);
561 CHECK(buffer == " -42.987");
562
563 buffer = jau::format_string("% 15.3f", 42.987);
564 CHECK(buffer == " 42.987");
565
566 buffer = jau::format_string("% s", "Hello testing");
567 CHECK(buffer == "Hello testing");
568
569 buffer = jau::format_string("% d", 1024);
570 CHECK(buffer == " 1024");
571
572 buffer = jau::format_string("% d", -1024);
573 CHECK(buffer == "-1024");
574
575 buffer = jau::format_string("% i", 1024);
576 CHECK(buffer == " 1024");
577
578 buffer = jau::format_string("% i", -1024);
579 CHECK(buffer == "-1024");
580
581 buffer = jau::format_string("% u", 1024);
582 CHECK(buffer == "1024");
583
584 buffer = jau::format_string("% u", 4294966272U);
585 CHECK(buffer == "4294966272");
586
587 buffer = jau::format_string("% o", 511);
588 CHECK(buffer == "777");
589
590 buffer = jau::format_string("% o", 4294966785U);
591 CHECK(buffer == "37777777001");
592
593 buffer = jau::format_string("% x", 305441741);
594 CHECK(buffer == "1234abcd");
595
596 buffer = jau::format_string("% x", 3989525555U);
597 CHECK(buffer == "edcb5433");
598
599 buffer = jau::format_string("% X", 305441741);
600 CHECK(buffer == "1234ABCD");
601
602 buffer = jau::format_string("% X", 3989525555U);
603 CHECK(buffer == "EDCB5433");
604
605 buffer = jau::format_string("% c", 'x');
606 CHECK(buffer == "x");
607}
608
609TEST_CASE("plus_flag", "[jau][std::string][jau::cfmt][flags]" ) {
610 std::string buffer;
611
612 buffer = jau::format_string("%+d", 42);
613 CHECK(buffer == "+42");
614
615 buffer = jau::format_string("%+d", -42);
616 CHECK(buffer == "-42");
617
618 buffer = jau::format_string("%+5d", 42);
619 CHECK(buffer == " +42");
620
621 buffer = jau::format_string("%+5d", -42);
622 CHECK(buffer == " -42");
623
624 buffer = jau::format_string("%+15d", 42);
625 CHECK(buffer == " +42");
626
627 buffer = jau::format_string("%+15d", -42);
628 CHECK(buffer == " -42");
629
630 buffer = jau::format_string("%+s", "Hello testing");
631 CHECK(buffer == "Hello testing");
632
633 buffer = jau::format_string("%+d", 1024);
634 CHECK(buffer == "+1024");
635
636 buffer = jau::format_string("%+d", -1024);
637 CHECK(buffer == "-1024");
638
639 buffer = jau::format_string("%+i", 1024);
640 CHECK(buffer == "+1024");
641
642 buffer = jau::format_string("%+i", -1024);
643 CHECK(buffer == "-1024");
644
645 buffer = jau::format_string("%+u", 1024);
646 CHECK(buffer == "1024");
647
648 buffer = jau::format_string("%+u", 4294966272U);
649 CHECK(buffer == "4294966272");
650
651 buffer = jau::format_string("%+o", 511);
652 CHECK(buffer == "777");
653
654 buffer = jau::format_string("%+o", 4294966785U);
655 CHECK(buffer == "37777777001");
656
657 buffer = jau::format_string("%+x", 305441741);
658 CHECK(buffer == "1234abcd");
659
660 buffer = jau::format_string("%+x", 3989525555U);
661 CHECK(buffer == "edcb5433");
662
663 buffer = jau::format_string("%+X", 305441741);
664 CHECK(buffer == "1234ABCD");
665
666 buffer = jau::format_string("%+X", 3989525555U);
667 CHECK(buffer == "EDCB5433");
668
669 buffer = jau::format_string("%+c", 'x');
670 CHECK(buffer == "x");
671
672 buffer = jau::format_string("%+.0d", 0);
673 CHECK(buffer == "+");
674}
675
676
677TEST_CASE("zero_flag", "[jau][std::string][jau::cfmt][flags]" ) {
678 std::string buffer;
679
680 buffer = jau::format_string("%0d", 42);
681 CHECK(buffer == "42");
682
683 buffer = jau::format_string("%0ld", 42L);
684 CHECK(buffer == "42");
685
686 buffer = jau::format_string("%0d", -42);
687 CHECK(buffer == "-42");
688
689 buffer = jau::format_string("%05d", 42);
690 CHECK(buffer == "00042");
691
692 buffer = jau::format_string("%05d", -42);
693 CHECK(buffer == "-0042");
694
695 buffer = jau::format_string("%015d", 42);
696 CHECK(buffer == "000000000000042");
697
698 buffer = jau::format_string("%015d", -42);
699 CHECK(buffer == "-00000000000042");
700
701 buffer = jau::format_string("%015.2f", 42.1234);
702 CHECK(buffer == "000000000042.12");
703
704 buffer = jau::format_string("%015.3f", 42.9876);
705 CHECK(buffer == "00000000042.988");
706
707 buffer = jau::format_string("%015.5f", -42.9876);
708 CHECK(buffer == "-00000042.98760");
709}
710
711
712TEST_CASE("left_flag", "[jau][std::string][jau::cfmt][flags]" ) {
713 std::string buffer;
714
715 buffer = jau::format_string("%-d", 42);
716 CHECK(buffer == "42");
717
718 buffer = jau::format_string("%-d", -42);
719 CHECK(buffer == "-42");
720
721 buffer = jau::format_string("%-5d", 42);
722 CHECK(buffer == "42 ");
723
724 buffer = jau::format_string("%-5d", -42);
725 CHECK(buffer == "-42 ");
726
727 buffer = jau::format_string("%-15d", 42);
728 CHECK(buffer == "42 ");
729
730 buffer = jau::format_string("%-15d", -42);
731 CHECK(buffer == "-42 ");
732
733 buffer = jau::format_string("%-0d", 42);
734 CHECK(buffer == "42");
735
736 buffer = jau::format_string("%-0d", -42);
737 CHECK(buffer == "-42");
738
739 buffer = jau::format_string("%-05d", 42);
740 CHECK(buffer == "42 ");
741
742 buffer = jau::format_string("%-05d", -42);
743 CHECK(buffer == "-42 ");
744
745 buffer = jau::format_string("%-015d", 42);
746 CHECK(buffer == "42 ");
747
748 buffer = jau::format_string("%-015d", -42);
749 CHECK(buffer == "-42 ");
750
751 buffer = jau::format_string("%0-d", 42);
752 CHECK(buffer == "42");
753
754 buffer = jau::format_string("%0-d", -42);
755 CHECK(buffer == "-42");
756
757 buffer = jau::format_string("%0-5d", 42);
758 CHECK(buffer == "42 ");
759
760 buffer = jau::format_string("%0-5d", -42);
761 CHECK(buffer == "-42 ");
762
763 buffer = jau::format_string("%0-15d", 42);
764 CHECK(buffer == "42 ");
765
766 buffer = jau::format_string("%0-15d", -42);
767 CHECK(buffer == "-42 ");
768
769 buffer = jau::format_string("%0-15.3e", -42.);
770 CHECK(buffer == "-4.200e+01 ");
771
772 buffer = jau::format_string("%0-15.3g", -42.);
773 CHECK(buffer == "-42.0 ");
774}
775
776
777TEST_CASE("hash_flag", "[jau][std::string][jau::cfmt][flags]" ) {
778 std::string buffer;
779
780 buffer = jau::format_string("%#.0x", 0);
781 CHECK(buffer == "");
782 buffer = jau::format_string("%#.1x", 0);
783 CHECK(buffer == "0");
784 buffer = jau::format_string("%#.0llx", (long long)0);
785 CHECK(buffer == "");
786 buffer = jau::format_string("%#.8x", 0x614e);
787 CHECK(buffer == "0x0000614e");
788 buffer = jau::format_string("%#b", 6);
789 CHECK(buffer == "0b110");
790}
791
792
793TEST_CASE("specifier", "[jau][std::string][jau::cfmt][specifier]" ) {
794 std::string buffer;
795
796 buffer = jau::format_string("Hello testing");
797 CHECK(buffer == "Hello testing");
798
799 buffer = jau::format_string("%s", "Hello testing");
800 CHECK(buffer == "Hello testing");
801
802 buffer = jau::format_string("%d", 1024);
803 CHECK(buffer == "1024");
804
805 buffer = jau::format_string("%d", -1024);
806 CHECK(buffer == "-1024");
807
808 buffer = jau::format_string("%i", 1024);
809 CHECK(buffer == "1024");
810
811 buffer = jau::format_string("%i", -1024);
812 CHECK(buffer == "-1024");
813
814 buffer = jau::format_string("%u", 1024);
815 CHECK(buffer == "1024");
816
817 buffer = jau::format_string("%u", 4294966272U);
818 CHECK(buffer == "4294966272");
819
820 buffer = jau::format_string("%o", 511);
821 CHECK(buffer == "777");
822
823 buffer = jau::format_string("%o", 4294966785U);
824 CHECK(buffer == "37777777001");
825
826 buffer = jau::format_string("%x", 305441741);
827 CHECK(buffer == "1234abcd");
828
829 buffer = jau::format_string("%x", 3989525555U);
830 CHECK(buffer == "edcb5433");
831
832 buffer = jau::format_string("%X", 305441741);
833 CHECK(buffer == "1234ABCD");
834
835 buffer = jau::format_string("%X", 3989525555U);
836 CHECK(buffer == "EDCB5433");
837
838 buffer = jau::format_string("%%");
839 CHECK(buffer == "%");
840}
841
842
843TEST_CASE("width", "[jau][std::string][jau::cfmt][width]" ) {
844 std::string buffer;
845
846 buffer = jau::format_string("%1s", "Hello testing");
847 CHECK(buffer == "Hello testing");
848
849 buffer = jau::format_string("%1d", 1024);
850 CHECK(buffer == "1024");
851
852 buffer = jau::format_string("%1d", -1024);
853 CHECK(buffer == "-1024");
854
855 buffer = jau::format_string("%1i", 1024);
856 CHECK(buffer == "1024");
857
858 buffer = jau::format_string("%1i", -1024);
859 CHECK(buffer == "-1024");
860
861 buffer = jau::format_string("%1u", 1024);
862 CHECK(buffer == "1024");
863
864 buffer = jau::format_string("%1u", 4294966272U);
865 CHECK(buffer == "4294966272");
866
867 buffer = jau::format_string("%1o", 511);
868 CHECK(buffer == "777");
869
870 buffer = jau::format_string("%1o", 4294966785U);
871 CHECK(buffer == "37777777001");
872
873 buffer = jau::format_string("%1x", 305441741);
874 CHECK(buffer == "1234abcd");
875
876 buffer = jau::format_string("%1x", 3989525555U);
877 CHECK(buffer == "edcb5433");
878
879 buffer = jau::format_string("%1X", 305441741);
880 CHECK(buffer == "1234ABCD");
881
882 buffer = jau::format_string("%1X", 3989525555U);
883 CHECK(buffer == "EDCB5433");
884
885 buffer = jau::format_string("%1c", 'x');
886 CHECK(buffer == "x");
887}
888
889
890TEST_CASE("width_20", "[jau][std::string][jau::cfmt][width]" ) {
891 std::string buffer;
892
893 buffer = jau::format_string("%20s", "Hello");
894 CHECK(buffer == " Hello");
895
896 buffer = jau::format_string("%20d", 1024);
897 CHECK(buffer == " 1024");
898
899 buffer = jau::format_string("%20d", -1024);
900 CHECK(buffer == " -1024");
901
902 buffer = jau::format_string("%20i", 1024);
903 CHECK(buffer == " 1024");
904
905 buffer = jau::format_string("%20i", -1024);
906 CHECK(buffer == " -1024");
907
908 buffer = jau::format_string("%20u", 1024);
909 CHECK(buffer == " 1024");
910
911 buffer = jau::format_string("%20u", 4294966272U);
912 CHECK(buffer == " 4294966272");
913
914 buffer = jau::format_string("%20o", 511);
915 CHECK(buffer == " 777");
916
917 buffer = jau::format_string("%20o", 4294966785U);
918 CHECK(buffer == " 37777777001");
919
920 buffer = jau::format_string("%20x", 305441741);
921 CHECK(buffer == " 1234abcd");
922
923 buffer = jau::format_string("%20x", 3989525555U);
924 CHECK(buffer == " edcb5433");
925
926 buffer = jau::format_string("%20X", 305441741);
927 CHECK(buffer == " 1234ABCD");
928
929 buffer = jau::format_string("%20X", 3989525555U);
930 CHECK(buffer == " EDCB5433");
931
932 buffer = jau::format_string("%20c", 'x');
933 CHECK(buffer == " x");
934}
935
936
937TEST_CASE("width_star_20", "[jau][std::string][jau::cfmt][width]" ) {
938 std::string buffer;
939
940 buffer = jau::format_string("%*s", 20, "Hello");
941 CHECK(buffer == " Hello");
942
943 buffer = jau::format_string("%*d", 20, 1024);
944 CHECK(buffer == " 1024");
945
946 buffer = jau::format_string("%*d", 20, -1024);
947 CHECK(buffer == " -1024");
948
949 buffer = jau::format_string("%*i", 20, 1024);
950 CHECK(buffer == " 1024");
951
952 buffer = jau::format_string("%*i", 20, -1024);
953 CHECK(buffer == " -1024");
954
955 buffer = jau::format_string("%*u", 20, 1024);
956 CHECK(buffer == " 1024");
957
958 buffer = jau::format_string("%*u", 20, 4294966272U);
959 CHECK(buffer == " 4294966272");
960
961 buffer = jau::format_string("%*o", 20, 511);
962 CHECK(buffer == " 777");
963
964 buffer = jau::format_string("%*o", 20, 4294966785U);
965 CHECK(buffer == " 37777777001");
966
967 buffer = jau::format_string("%*x", 20, 305441741);
968 CHECK(buffer == " 1234abcd");
969
970 buffer = jau::format_string("%*x", 20, 3989525555U);
971 CHECK(buffer == " edcb5433");
972
973 buffer = jau::format_string("%*X", 20, 305441741);
974 CHECK(buffer == " 1234ABCD");
975
976 buffer = jau::format_string("%*X", 20, 3989525555U);
977 CHECK(buffer == " EDCB5433");
978
979 buffer = jau::format_string("%*c", 20,'x');
980 CHECK(buffer == " x");
981}
982
983
984TEST_CASE("width_left_20", "[jau][std::string][jau::cfmt][width]" ) {
985 std::string buffer;
986
987 buffer = jau::format_string("%-20s", "Hello");
988 CHECK(buffer == "Hello ");
989
990 buffer = jau::format_string("%-20d", 1024);
991 CHECK(buffer == "1024 ");
992
993 buffer = jau::format_string("%-20d", -1024);
994 CHECK(buffer == "-1024 ");
995
996 buffer = jau::format_string("%-20i", 1024);
997 CHECK(buffer == "1024 ");
998
999 buffer = jau::format_string("%-20i", -1024);
1000 CHECK(buffer == "-1024 ");
1001
1002 buffer = jau::format_string("%-20u", 1024);
1003 CHECK(buffer == "1024 ");
1004
1005 buffer = jau::format_string("%-20.4f", 1024.1234);
1006 CHECK(buffer == "1024.1234 ");
1007
1008 buffer = jau::format_string("%-20u", 4294966272U);
1009 CHECK(buffer == "4294966272 ");
1010
1011 buffer = jau::format_string("%-20o", 511);
1012 CHECK(buffer == "777 ");
1013
1014 buffer = jau::format_string("%-20o", 4294966785U);
1015 CHECK(buffer == "37777777001 ");
1016
1017 buffer = jau::format_string("%-20x", 305441741);
1018 CHECK(buffer == "1234abcd ");
1019
1020 buffer = jau::format_string("%-20x", 3989525555U);
1021 CHECK(buffer == "edcb5433 ");
1022
1023 buffer = jau::format_string("%-20X", 305441741);
1024 CHECK(buffer == "1234ABCD ");
1025
1026 buffer = jau::format_string("%-20X", 3989525555U);
1027 CHECK(buffer == "EDCB5433 ");
1028
1029 buffer = jau::format_string("%-20c", 'x');
1030 CHECK(buffer == "x ");
1031
1032 buffer = jau::format_string("|%5d| |%-2d| |%5d|", 9, 9, 9);
1033 CHECK(buffer == "| 9| |9 | | 9|");
1034
1035 buffer = jau::format_string("|%5d| |%-2d| |%5d|", 10, 10, 10);
1036 CHECK(buffer == "| 10| |10| | 10|");
1037
1038 buffer = jau::format_string("|%5d| |%-12d| |%5d|", 9, 9, 9);
1039 CHECK(buffer == "| 9| |9 | | 9|");
1040
1041 buffer = jau::format_string("|%5d| |%-12d| |%5d|", 10, 10, 10);
1042 CHECK(buffer == "| 10| |10 | | 10|");
1043}
1044
1045
1046TEST_CASE("zero_width_left_20", "[jau][std::string][jau::cfmt][width]" ) {
1047 std::string buffer;
1048
1049 buffer = jau::format_string("%0-20s", "Hello");
1050 CHECK(buffer == "Hello ");
1051
1052 buffer = jau::format_string("%0-20d", 1024);
1053 CHECK(buffer == "1024 ");
1054
1055 buffer = jau::format_string("%0-20d", -1024);
1056 CHECK(buffer == "-1024 ");
1057
1058 buffer = jau::format_string("%0-20i", 1024);
1059 CHECK(buffer == "1024 ");
1060
1061 buffer = jau::format_string("%0-20i", -1024);
1062 CHECK(buffer == "-1024 ");
1063
1064 buffer = jau::format_string("%0-20u", 1024);
1065 CHECK(buffer == "1024 ");
1066
1067 buffer = jau::format_string("%0-20u", 4294966272U);
1068 CHECK(buffer == "4294966272 ");
1069
1070 buffer = jau::format_string("%0-20o", 511);
1071 CHECK(buffer == "777 ");
1072
1073 buffer = jau::format_string("%0-20o", 4294966785U);
1074 CHECK(buffer == "37777777001 ");
1075
1076 buffer = jau::format_string("%0-20x", 305441741);
1077 CHECK(buffer == "1234abcd ");
1078
1079 buffer = jau::format_string("%0-20x", 3989525555U);
1080 CHECK(buffer == "edcb5433 ");
1081
1082 buffer = jau::format_string("%0-20X", 305441741);
1083 CHECK(buffer == "1234ABCD ");
1084
1085 buffer = jau::format_string("%0-20X", 3989525555U);
1086 CHECK(buffer == "EDCB5433 ");
1087
1088 buffer = jau::format_string("%0-20c", 'x');
1089 CHECK(buffer == "x ");
1090}
1091
1092
1093TEST_CASE("width_20", "[jau][std::string][jau::cfmt][padding]" ) {
1094 std::string buffer;
1095
1096 buffer = jau::format_string("%020d", 1024);
1097 CHECK(buffer == "00000000000000001024");
1098
1099 buffer = jau::format_string("%020d", -1024);
1100 CHECK(buffer == "-0000000000000001024");
1101
1102 buffer = jau::format_string("%020i", 1024);
1103 CHECK(buffer == "00000000000000001024");
1104
1105 buffer = jau::format_string("%020i", -1024);
1106 CHECK(buffer == "-0000000000000001024");
1107
1108 buffer = jau::format_string("%020u", 1024);
1109 CHECK(buffer == "00000000000000001024");
1110
1111 buffer = jau::format_string("%020u", 4294966272U);
1112 CHECK(buffer == "00000000004294966272");
1113
1114 buffer = jau::format_string("%020o", 511);
1115 CHECK(buffer == "00000000000000000777");
1116
1117 buffer = jau::format_string("%020o", 4294966785U);
1118 CHECK(buffer == "00000000037777777001");
1119
1120 buffer = jau::format_string("%020x", 305441741);
1121 CHECK(buffer == "0000000000001234abcd");
1122
1123 buffer = jau::format_string("%020x", 3989525555U);
1124 CHECK(buffer == "000000000000edcb5433");
1125
1126 buffer = jau::format_string("%020X", 305441741);
1127 CHECK(buffer == "0000000000001234ABCD");
1128
1129 buffer = jau::format_string("%020X", 3989525555U);
1130 CHECK(buffer == "000000000000EDCB5433");
1131}
1132
1133
1134TEST_CASE("precision_20", "[jau][std::string][jau::cfmt][padding]" ) {
1135 std::string buffer;
1136
1137 buffer = jau::format_string("%.20d", 1024);
1138 CHECK(buffer == "00000000000000001024");
1139
1140 buffer = jau::format_string("%.20d", -1024);
1141 CHECK(buffer == "-00000000000000001024");
1142
1143 buffer = jau::format_string("%.20i", 1024);
1144 CHECK(buffer == "00000000000000001024");
1145
1146 buffer = jau::format_string("%.20i", -1024);
1147 CHECK(buffer == "-00000000000000001024");
1148
1149 buffer = jau::format_string("%.20u", 1024);
1150 CHECK(buffer == "00000000000000001024");
1151
1152 buffer = jau::format_string("%.20u", 4294966272U);
1153 CHECK(buffer == "00000000004294966272");
1154
1155 buffer = jau::format_string("%.20o", 511);
1156 CHECK(buffer == "00000000000000000777");
1157
1158 buffer = jau::format_string("%.20o", 4294966785U);
1159 CHECK(buffer == "00000000037777777001");
1160
1161 buffer = jau::format_string("%.20x", 305441741);
1162 CHECK(buffer == "0000000000001234abcd");
1163
1164 buffer = jau::format_string("%.20x", 3989525555U);
1165 CHECK(buffer == "000000000000edcb5433");
1166
1167 buffer = jau::format_string("%.20X", 305441741);
1168 CHECK(buffer == "0000000000001234ABCD");
1169
1170 buffer = jau::format_string("%.20X", 3989525555U);
1171 CHECK(buffer == "000000000000EDCB5433");
1172}
1173
1174
1175TEST_CASE("hash_zero_width_20", "[jau][std::string][jau::cfmt][padding]" ) {
1176 std::string buffer;
1177
1178 buffer = jau::format_string("%#020d", 1024);
1179 CHECK(buffer == "00000000000000001024");
1180
1181 buffer = jau::format_string("%#020d", -1024);
1182 CHECK(buffer == "-0000000000000001024");
1183
1184 buffer = jau::format_string("%#020i", 1024);
1185 CHECK(buffer == "00000000000000001024");
1186
1187 buffer = jau::format_string("%#020i", -1024);
1188 CHECK(buffer == "-0000000000000001024");
1189
1190 buffer = jau::format_string("%#020u", 1024);
1191 CHECK(buffer == "00000000000000001024");
1192
1193 buffer = jau::format_string("%#020u", 4294966272U);
1194 CHECK(buffer == "00000000004294966272");
1195
1196 buffer = jau::format_string("%#020o", 511);
1197 CHECK(buffer == "00000000000000000777");
1198
1199 buffer = jau::format_string("%#020o", 4294966785U);
1200 CHECK(buffer == "00000000037777777001");
1201
1202 buffer = jau::format_string("%#020x", 305441741);
1203 CHECK(buffer == "0x00000000001234abcd");
1204
1205 buffer = jau::format_string("%#020x", 3989525555U);
1206 CHECK(buffer == "0x0000000000edcb5433");
1207
1208 buffer = jau::format_string("%#020X", 305441741);
1209 CHECK(buffer == "0X00000000001234ABCD");
1210
1211 buffer = jau::format_string("%#020X", 3989525555U);
1212 CHECK(buffer == "0X0000000000EDCB5433");
1213}
1214
1215
1216TEST_CASE("hash_width_20", "[jau][std::string][jau::cfmt][padding]" ) {
1217 std::string buffer;
1218
1219 buffer = jau::format_string("%#20d", 1024);
1220 CHECK(buffer == " 1024");
1221
1222 buffer = jau::format_string("%#20d", -1024);
1223 CHECK(buffer == " -1024");
1224
1225 buffer = jau::format_string("%#20i", 1024);
1226 CHECK(buffer == " 1024");
1227
1228 buffer = jau::format_string("%#20i", -1024);
1229 CHECK(buffer == " -1024");
1230
1231 buffer = jau::format_string("%#20u", 1024);
1232 CHECK(buffer == " 1024");
1233
1234 buffer = jau::format_string("%#20u", 4294966272U);
1235 CHECK(buffer == " 4294966272");
1236
1237 buffer = jau::format_string("%#20o", 511);
1238 CHECK(buffer == " 0777");
1239
1240 buffer = jau::format_string("%#20o", 4294966785U);
1241 CHECK(buffer == " 037777777001");
1242
1243 buffer = jau::format_string("%#20x", 305441741);
1244 CHECK(buffer == " 0x1234abcd");
1245
1246 buffer = jau::format_string("%#20x", 3989525555U);
1247 CHECK(buffer == " 0xedcb5433");
1248
1249 buffer = jau::format_string("%#20X", 305441741);
1250 CHECK(buffer == " 0X1234ABCD");
1251
1252 buffer = jau::format_string("%#20X", 3989525555U);
1253 CHECK(buffer == " 0XEDCB5433");
1254}
1255
1256
1257TEST_CASE("width_20_precision_5", "[jau][std::string][jau::cfmt][padding]" ) {
1258 std::string buffer;
1259
1260 buffer = jau::format_string("%20.5d", 1024);
1261 CHECK(buffer == " 01024");
1262
1263 buffer = jau::format_string("%20.5d", -1024);
1264 CHECK(buffer == " -01024");
1265
1266 buffer = jau::format_string("%20.5i", 1024);
1267 CHECK(buffer == " 01024");
1268
1269 buffer = jau::format_string("%20.5i", -1024);
1270 CHECK(buffer == " -01024");
1271
1272 buffer = jau::format_string("%20.5u", 1024);
1273 CHECK(buffer == " 01024");
1274
1275 buffer = jau::format_string("%20.5u", 4294966272U);
1276 CHECK(buffer == " 4294966272");
1277
1278 buffer = jau::format_string("%20.5o", 511);
1279 CHECK(buffer == " 00777");
1280
1281 buffer = jau::format_string("%20.5o", 4294966785U);
1282 CHECK(buffer == " 37777777001");
1283
1284 buffer = jau::format_string("%20.5x", 305441741);
1285 CHECK(buffer == " 1234abcd");
1286
1287 buffer = jau::format_string("%20.10x", 3989525555U);
1288 CHECK(buffer == " 00edcb5433");
1289
1290 buffer = jau::format_string("%20.5X", 305441741);
1291 CHECK(buffer == " 1234ABCD");
1292
1293 buffer = jau::format_string("%20.10X", 3989525555U);
1294 CHECK(buffer == " 00EDCB5433");
1295}
1296
1297
1298TEST_CASE("padding neg_numbers", "[jau][std::string][jau::cfmt][padding]" ) {
1299 std::string buffer;
1300
1301 // space padding
1302 buffer = jau::format_string("% 1d", -5);
1303 CHECK(buffer == "-5");
1304
1305 buffer = jau::format_string("% 2d", -5);
1306 CHECK(buffer == "-5");
1307
1308 buffer = jau::format_string("% 3d", -5);
1309 CHECK(buffer == " -5");
1310
1311 buffer = jau::format_string("% 4d", -5);
1312 CHECK(buffer == " -5");
1313
1314 // zero padding
1315 buffer = jau::format_string("%01d", -5);
1316 CHECK(buffer == "-5");
1317
1318 buffer = jau::format_string("%02d", -5);
1319 CHECK(buffer == "-5");
1320
1321 buffer = jau::format_string("%03d", -5);
1322 CHECK(buffer == "-05");
1323
1324 buffer = jau::format_string("%04d", -5);
1325 CHECK(buffer == "-005");
1326}
1327
1328
1329TEST_CASE("float padding_neg_numbers", "[jau][std::string][jau::cfmt][float]" ) {
1330 std::string buffer;
1331
1332 // space padding
1333 buffer = jau::format_string("% 3.1f", -5.);
1334 CHECK(buffer == "-5.0");
1335
1336 buffer = jau::format_string("% 4.1f", -5.);
1337 CHECK(buffer == "-5.0");
1338
1339 buffer = jau::format_string("% 5.1f", -5.);
1340 CHECK(buffer == " -5.0");
1341
1342 buffer = jau::format_string("% 6.1g", -5.);
1343 CHECK(buffer == " -5");
1344
1345 buffer = jau::format_string("% 6.1e", -5.);
1346 CHECK(buffer == "-5.0e+00");
1347
1348 buffer = jau::format_string("% 10.1e", -5.);
1349 CHECK(buffer == " -5.0e+00");
1350
1351 // zero padding
1352 buffer = jau::format_string("%03.1f", -5.);
1353 CHECK(buffer == "-5.0");
1354
1355 buffer = jau::format_string("%04.1f", -5.);
1356 CHECK(buffer == "-5.0");
1357
1358 buffer = jau::format_string("%05.1f", -5.);
1359 CHECK(buffer == "-05.0");
1360
1361 // zero padding no decimal point
1362 buffer = jau::format_string("%01.0f", -5.);
1363 CHECK(buffer == "-5");
1364
1365 buffer = jau::format_string("%02.0f", -5.);
1366 CHECK(buffer == "-5");
1367
1368 buffer = jau::format_string("%03.0f", -5.);
1369 CHECK(buffer == "-05");
1370
1371 buffer = jau::format_string("%010.1e", -5.);
1372 CHECK(buffer == "-005.0e+00");
1373
1374 buffer = jau::format_string("%07.0E", -5.);
1375 CHECK(buffer == "-05E+00");
1376
1377 buffer = jau::format_string("%03.0g", -5.);
1378 CHECK(buffer == "-05");
1379}
1380
1381TEST_CASE("length", "[jau][std::string][jau::cfmt][length]" ) {
1382 std::string buffer;
1383
1384 buffer = jau::format_string("%.0s", "Hello testing");
1385 CHECK(buffer == "");
1386
1387 buffer = jau::format_string("%20.0s", "Hello testing");
1388 CHECK(buffer == " ");
1389
1390 buffer = jau::format_string("%.s", "Hello testing");
1391 CHECK(buffer == "");
1392
1393 buffer = jau::format_string("%20.s", "Hello testing");
1394 CHECK(buffer == " ");
1395
1396 buffer = jau::format_string("%20.0d", 1024);
1397 CHECK(buffer == " 1024");
1398
1399 buffer = jau::format_string("%20.0d", -1024);
1400 CHECK(buffer == " -1024");
1401
1402 buffer = jau::format_string("%20.d", 0);
1403 CHECK(buffer == " ");
1404
1405 buffer = jau::format_string("%20.0i", 1024);
1406 CHECK(buffer == " 1024");
1407
1408 buffer = jau::format_string("%20.i", -1024);
1409 CHECK(buffer == " -1024");
1410
1411 buffer = jau::format_string("%20.i", 0);
1412 CHECK(buffer == " ");
1413
1414 buffer = jau::format_string("%20.u", 1024);
1415 CHECK(buffer == " 1024");
1416
1417 buffer = jau::format_string("%20.0u", 4294966272U);
1418 CHECK(buffer == " 4294966272");
1419
1420 buffer = jau::format_string("%20.u", 0U);
1421 CHECK(buffer == " ");
1422
1423 buffer = jau::format_string("%20.o", 511);
1424 CHECK(buffer == " 777");
1425
1426 buffer = jau::format_string("%20.0o", 4294966785U);
1427 CHECK(buffer == " 37777777001");
1428
1429 buffer = jau::format_string("%20.o", 0U);
1430 CHECK(buffer == " ");
1431
1432 buffer = jau::format_string("%20.x", 305441741);
1433 CHECK(buffer == " 1234abcd");
1434
1435 buffer = jau::format_string("%50.x", 305441741);
1436 CHECK(buffer == " 1234abcd");
1437
1438 buffer = jau::format_string("%50.x%10.u", 305441741, 12345);
1439 CHECK(buffer == " 1234abcd 12345");
1440
1441 buffer = jau::format_string("%20.0x", 3989525555U);
1442 CHECK(buffer == " edcb5433");
1443
1444 buffer = jau::format_string("%20.x", 0U);
1445 CHECK(buffer == " ");
1446
1447 buffer = jau::format_string("%20.X", 305441741);
1448 CHECK(buffer == " 1234ABCD");
1449
1450 buffer = jau::format_string("%20.0X", 3989525555U);
1451 CHECK(buffer == " EDCB5433");
1452
1453 buffer = jau::format_string("%20.X", 0U);
1454 CHECK(buffer == " ");
1455
1456 buffer = jau::format_string("%02.0u", 0U);
1457 CHECK(buffer == " ");
1458
1459 buffer = jau::format_string("%02.0d", 0);
1460 CHECK(buffer == " ");
1461}
1462
1463
1464TEST_CASE("float", "[jau][std::string][jau::cfmt][float]" ) {
1465 std::string buffer;
1466
1467 // test special-case floats using math.h macros
1468 buffer = jau::format_string("%8f", NAN);
1469 CHECK(buffer == " nan");
1470
1471 buffer = jau::format_string("%8f", INFINITY);
1472 CHECK(buffer == " inf");
1473
1474 buffer = jau::format_string("%-8f", -INFINITY);
1475 CHECK(buffer == "-inf ");
1476
1477 buffer = jau::format_string("%+8e", INFINITY);
1478 CHECK(buffer == " +inf");
1479
1480 buffer = jau::format_string("%.4f", 3.1415354); // NOLINT
1481 CHECK(buffer == "3.1415");
1482
1483 buffer = jau::format_string("%.3f", 30343.1415354);
1484 CHECK(buffer == "30343.142");
1485
1486 buffer = jau::format_string("%.0f", 34.1415354);
1487 CHECK(buffer == "34");
1488
1489 buffer = jau::format_string("%.0f", 1.3);
1490 CHECK(buffer == "1");
1491
1492 buffer = jau::format_string("%.0f", 1.55);
1493 CHECK(buffer == "2");
1494
1495 buffer = jau::format_string("%.1f", 1.64);
1496 CHECK(buffer == "1.6");
1497
1498 buffer = jau::format_string("%.2f", 42.8952);
1499 CHECK(buffer == "42.90");
1500
1501 buffer = jau::format_string("%.9f", 42.8952);
1502 CHECK(buffer == "42.895200000");
1503
1504 buffer = jau::format_string("%.10f", 42.895223);
1505 CHECK(buffer == "42.8952230000");
1506
1507 // assuming not being truncated to 9 digits. (19)
1508 buffer = jau::format_string("%.12f", 42.987654321098);
1509 CHECK(buffer == "42.987654321098");
1510
1511 // assuming not being truncated to 9 digits, but rounded
1512 buffer = jau::format_string("%.12f", 42.98765432109899);
1513 CHECK(buffer == "42.987654321099");
1514
1515 // 14
1516 buffer = jau::format_string("%.14f", 42.98765432109876);
1517 CHECK(buffer == "42.98765432109876");
1518 // 14 rounded
1519 buffer = jau::format_string("%.14f", 42.9876543210987699);
1520 CHECK(buffer == "42.98765432109877");
1521
1522 // 16 truncated to 14 (max precision)
1523 buffer = jau::format_string("%.16f", 42.9876543210987612);
1524 CHECK(buffer == "42.9876543210987600");
1525
1526 // 16 truncated to 14 (max precision) and rounded
1527 buffer = jau::format_string("%.16f", 42.9876543210987654);
1528 CHECK(buffer == "42.9876543210987700");
1529
1530 buffer = jau::format_string("%6.2f", 42.8952);
1531 CHECK(buffer == " 42.90");
1532
1533 buffer = jau::format_string("%+6.2f", 42.8952);
1534 CHECK(buffer == "+42.90");
1535
1536 buffer = jau::format_string("%+5.1f", 42.9252);
1537 CHECK(buffer == "+42.9");
1538
1539 buffer = jau::format_string("%f", 42.5);
1540 CHECK(buffer == "42.500000");
1541
1542 buffer = jau::format_string("%.1f", 42.5);
1543 CHECK(buffer == "42.5");
1544
1545 buffer = jau::format_string("%f", 42167.0);
1546 CHECK(buffer == "42167.000000");
1547
1548 buffer = jau::format_string("%.9f", -12345.987654321);
1549 CHECK(buffer == "-12345.987654321");
1550
1551 buffer = jau::format_string("%.1f", 3.999);
1552 CHECK(buffer == "4.0");
1553
1554 buffer = jau::format_string("%.0f", 3.5);
1555 CHECK(buffer == "4");
1556
1557 buffer = jau::format_string("%.0f", 4.5);
1558 CHECK(buffer == "4");
1559
1560 buffer = jau::format_string("%.0f", 3.49);
1561 CHECK(buffer == "3");
1562
1563 buffer = jau::format_string("%.1f", 3.49);
1564 CHECK(buffer == "3.5");
1565
1566 buffer = jau::format_string("a%-5.1f", 0.5);
1567 CHECK(buffer == "a0.5 ");
1568
1569 buffer = jau::format_string("a%-5.1fend", 0.5);
1570 CHECK(buffer == "a0.5 end");
1571
1572 buffer = jau::format_string("%G", 12345.678);
1573 CHECK(buffer == "12345.7");
1574
1575 buffer = jau::format_string("%.7G", 12345.678);
1576 CHECK(buffer == "12345.68");
1577
1578 buffer = jau::format_string("%.5G", 123456789.);
1579 CHECK(buffer == "1.2346E+08");
1580
1581 buffer = jau::format_string("%.6G", 12345.);
1582 CHECK(buffer == "12345.0");
1583
1584 buffer = jau::format_string("%+12.4g", 123456789.);
1585 CHECK(buffer == " +1.235e+08");
1586
1587 buffer = jau::format_string("%.2G", 0.001234);
1588 CHECK(buffer == "0.0012");
1589
1590 buffer = jau::format_string("%+10.4G", 0.001234);
1591 CHECK(buffer == " +0.001234");
1592
1593 buffer = jau::format_string("%+012.4g", 0.00001234);
1594 CHECK(buffer == "+001.234e-05");
1595
1596 buffer = jau::format_string("%.3g", -1.2345e-308);
1597 CHECK(buffer == "-1.23e-308");
1598
1599 buffer = jau::format_string("%+.3E", 1.23e+308);
1600 CHECK(buffer == "+1.230E+308");
1601
1602 // out of range for float: should switch to exp notation if supported, else empty
1603 buffer = jau::format_string("%.1f", 1E20);
1604 CHECK(buffer == "1.0e+20");
1605
1606 buffer = jau::format_string("%.5f", -1.12345);
1607 CHECK(buffer == "-1.12345");
1608
1609 buffer = jau::format_string("%.5f", -1.00000e20);
1610 CHECK(buffer == "-1.00000e+20");
1611
1612 // brute force float
1613 bool fail = false;
1614 std::stringstream str;
1615 str.precision(5);
1616 for (float i = -100000; i < 100000; i += 1) { // NOLINT
1617 buffer = jau::format_string("%.5f", i / 10000);
1618 str.str("");
1619 str << std::fixed << i / 10000;
1620 fail = fail || buffer != str.str();
1621 }
1622 CHECK(!fail);
1623
1624 // brute force exp
1625 fail = false;
1626 str.setf(std::ios::scientific, std::ios::floatfield);
1627 for (float i = -1e20; i < 1e20; i += 1e15) { // NOLINT
1628 buffer = jau::format_string("%.5f", i);
1629 buffer.shrink_to_fit();
1630 str.str("");
1631 str << i;
1632 REQUIRE(buffer == str.str());
1633 fail = fail || buffer != str.str();
1634 }
1635 CHECK(!fail);
1636}
1637
1638
1639TEST_CASE("types", "[jau][std::string][jau::cfmt][types]" ) {
1640 std::string buffer;
1641
1642 buffer = jau::format_string("%i", 0);
1643 CHECK(buffer == "0");
1644
1645 buffer = jau::format_string("%i", 1234);
1646 CHECK(buffer == "1234");
1647
1648 buffer = jau::format_string("%i", 32767);
1649 CHECK(buffer == "32767");
1650
1651 buffer = jau::format_string("%i", -32767);
1652 CHECK(buffer == "-32767");
1653
1654 buffer = jau::format_string("%li", 30L);
1655 CHECK(buffer == "30");
1656
1657 buffer = jau::format_string("%li", -2147483647L);
1658 CHECK(buffer == "-2147483647");
1659
1660 buffer = jau::format_string("%li", 2147483647L);
1661 CHECK(buffer == "2147483647");
1662
1663 buffer = jau::format_string("%lli", 30LL);
1664 CHECK(buffer == "30");
1665
1666 buffer = jau::format_string("%lli", -9223372036854775807LL);
1667 CHECK(buffer == "-9223372036854775807");
1668
1669 buffer = jau::format_string("%lli", 9223372036854775807LL);
1670 CHECK(buffer == "9223372036854775807");
1671
1672 buffer = jau::format_string("%lu", 100000L);
1673 CHECK(buffer == "100000");
1674
1675 buffer = jau::format_string("%lu", 0xFFFFFFFFL);
1676 CHECK(buffer == "4294967295");
1677
1678 buffer = jau::format_string("%llu", 281474976710656LLU);
1679 CHECK(buffer == "281474976710656");
1680
1681 buffer = jau::format_string("%llu", 18446744073709551615LLU);
1682 CHECK(buffer == "18446744073709551615");
1683
1684 buffer = jau::format_string("%zu", 2147483647UL);
1685 CHECK(buffer == "2147483647");
1686
1687 buffer = jau::format_string("%zd", 2147483647L);
1688 CHECK(buffer == "2147483647");
1689
1690 // failed intentionally unsigned -> signed
1691 static_assert(0 < jau::cfmt::checkLine("%zd", 2147483647UL));
1692 // buffer = jau::format_string("%zd", 2147483647UL);
1693 // CHECK(buffer == "2147483647");
1694
1695 if (sizeof(size_t) == sizeof(long)) {
1696 buffer = jau::format_string("%zi", -2147483647L);
1697 CHECK(buffer == "-2147483647");
1698 }
1699 else {
1700 buffer = jau::format_string("%zi", -2147483647LL);
1701 CHECK(buffer == "-2147483647");
1702 }
1703
1704 buffer = jau::format_string("%b", 60000);
1705 CHECK(buffer == "1110101001100000");
1706
1707 buffer = jau::format_string("%lb", 12345678L);
1708 CHECK(buffer == "101111000110000101001110");
1709
1710 buffer = jau::format_string("%o", 60000);
1711 CHECK(buffer == "165140");
1712
1713 buffer = jau::format_string("%lo", 12345678L);
1714 CHECK(buffer == "57060516");
1715
1716 buffer = jau::format_string("%lx", 0x12345678L);
1717 CHECK(buffer == "12345678");
1718
1719 buffer = jau::format_string("%llx", 0x1234567891234567LLU);
1720 CHECK(buffer == "1234567891234567");
1721
1722 buffer = jau::format_string("%lx", 0xabcdefabL);
1723 CHECK(buffer == "abcdefab");
1724
1725 buffer = jau::format_string("%lX", 0xabcdefabL);
1726 CHECK(buffer == "ABCDEFAB");
1727
1728 buffer = jau::format_string("%c", 'v');
1729 CHECK(buffer == "v");
1730
1731 buffer = jau::format_string("%cv", 'w');
1732 CHECK(buffer == "wv");
1733
1734 buffer = jau::format_string("%s", "A Test");
1735 CHECK(buffer == "A Test");
1736
1737 static_assert(0 < jau::cfmt::checkLine("%hhu", 0xFFU)); // size unsigned int > unsigned char (intentional failure)
1738 static_assert(0 == jau::cfmt::checkLine("%hhu", 0xFF_u8));
1739 buffer = jau::format_string("%hhu", 0xFF_u8);
1740 CHECK(buffer == "255");
1741
1742 // intentionally fails: given arg size > hh char
1743 static_assert(0 < jau::cfmt::checkLine("%hhu", 0xFFFFUL)); // size unsigned long > unsigned char (intentional failure)
1744 // buffer = jau::format_string("%hhu", 0xFFFFUL);
1745 // CHECK(buffer == "255");
1746
1747 static_assert(0 < jau::cfmt::checkLine("%hu", 0x123456UL)); // size unsigned long > unsigned short (intentional failure)
1748 static_assert(0 == jau::cfmt::checkLine("%hu", 0x1234_u16));
1749 buffer = jau::format_string("%hu", 0x1234_u16); // size unsigned long > unsigned short
1750 CHECK(buffer == "4660");
1751
1752 static_assert(0 < jau::cfmt::checkLine("%s%hhi %hu", "Test", 10000, 0xFFFFFFFF));
1753 static_assert(0 == jau::cfmt::checkLine("%s%hhi %hu", "Test", 16_i8, 0xFFFF_u16));
1754 buffer = jau::format_string("%s%hhi %hu", "Test", (char)16, (unsigned short)0xFFFF);
1755 CHECK(buffer == "Test16 65535");
1756
1757 buffer = jau::format_string("%tx", &buffer[10] - &buffer[0]);
1758 CHECK(buffer == "a");
1759
1760// TBD
1761 if (sizeof(intmax_t) == sizeof(long)) {
1762 buffer = jau::format_string("%ji", -2147483647L);
1763 CHECK(buffer == "-2147483647");
1764 }
1765 else {
1766 buffer = jau::format_string("%ji", -2147483647LL);
1767 CHECK(buffer == "-2147483647");
1768 }
1769}
1770
1771
1772TEST_CASE("pointer", "[jau][std::string][jau::cfmt][pointer]" ) {
1773 std::string buffer;
1774
1775#if 0
1776 buffer = jau::format_string("%p", (void*)0x1234U);
1777 if (sizeof(void*) == 4U) {
1778 CHECK(buffer == "00001234");
1779 }
1780 else {
1781 CHECK(buffer == "0000000000001234");
1782 }
1783
1784 buffer = jau::format_string("%p", (void*)0x12345678U);
1785 if (sizeof(void*) == 4U) {
1786 CHECK(buffer == "12345678");
1787 }
1788 else {
1789 CHECK(buffer == "0000000012345678");
1790 }
1791
1792 buffer = jau::format_string("%p-%p", (void*)0x12345678U, (void*)0x7EDCBA98U);
1793 if (sizeof(void*) == 4U) {
1794 CHECK(buffer == "12345678-7EDCBA98");
1795 }
1796 else {
1797 CHECK(buffer == "0000000012345678-000000007EDCBA98");
1798 }
1799
1800 if (sizeof(uintptr_t) == sizeof(uint64_t)) {
1801 buffer = jau::format_string("%p", (void*)(uintptr_t)0xFFFFFFFFU); // NOLINT
1802 CHECK(buffer == "00000000FFFFFFFF");
1803 }
1804 else {
1805 buffer = jau::format_string("%p", (void*)(uintptr_t)0xFFFFFFFFU); // NOLINT
1806 CHECK(buffer == "FFFFFFFF");
1807 }
1808#else
1809 // %#x or %#lx
1810 buffer = jau::format_string("%p", (void*)0x1234U);
1811 CHECK(buffer == "0x1234");
1812
1813 buffer = jau::format_string("%p", (void*)0x12345678U);
1814 CHECK(buffer == "0x12345678");
1815
1816 buffer = jau::format_string("%p-%p", (void*)0x12345678U, (void*)0x7EDCBA98U);
1817 CHECK(buffer == "0x12345678-0x7edcba98");
1818
1819 buffer = jau::format_string("%p", (void*)(uintptr_t)0xFFFFFFFFU); // NOLINT
1820 CHECK(buffer == "0xffffffff");
1821#endif
1822}
1823
1824
1825TEST_CASE("unknown flag", "[jau][std::string][jau::cfmt][error]" ) {
1826 std::string buffer;
1827
1828 // we inject an error message
1829 buffer = jau::format_string("%kmarco", 42, 37); // orig "kmarco"
1830 const size_t q = buffer.find("<E#", 0);
1831 CHECK( q != std::string::npos );
1832}
1833
1834
1835TEST_CASE("string length", "[jau][std::string][jau::cfmt][stringlen]" ) {
1836 std::string buffer;
1837
1838 buffer = jau::format_string("%.4s", "This is a test");
1839 CHECK(buffer == "This");
1840
1841 buffer = jau::format_string("%.4s", "test");
1842 CHECK(buffer == "test");
1843
1844 buffer = jau::format_string("%.7s", "123");
1845 CHECK(buffer == "123");
1846
1847 buffer = jau::format_string("%.7s", "");
1848 CHECK(buffer == "");
1849
1850 buffer = jau::format_string("%.4s%.2s", "123456", "abcdef");
1851 CHECK(buffer == "1234ab");
1852
1853 // we inject an error message
1854 buffer = jau::format_string("%.4.2s", "123456"); // orig ".2s"
1855 const size_t q = buffer.find("<E#", 0);
1856 CHECK( q != std::string::npos );
1857
1858 buffer = jau::format_string("%.*s", 3, "123456");
1859 CHECK(buffer == "123");
1860}
1861
1862TEST_CASE("misc", "[jau][std::string][jau::cfmt][misc]" ) {
1863 std::string buffer;
1864
1865 buffer = jau::format_string("%u%u%ctest%d %s", 5, 3000, 'a', -20, "bit");
1866 CHECK(buffer == "53000atest-20 bit");
1867
1868 buffer = jau::format_string("%.*f", 2, 0.33333333);
1869 CHECK(buffer == "0.33");
1870
1871 buffer = jau::format_string("%.*d", -1, 1);
1872 CHECK(buffer == "1");
1873
1874 buffer = jau::format_string("%.3s", "foobar");
1875 CHECK(buffer == "foo");
1876
1877 buffer = jau::format_string("% .0d", 0);
1878 CHECK(buffer == " ");
1879
1880 buffer = jau::format_string("%10.5d", 4);
1881 CHECK(buffer == " 00004");
1882
1883 buffer = jau::format_string("%*sx", -3, "hi");
1884 CHECK(buffer == "hi x");
1885
1886 buffer = jau::format_string("%.*g", 2, 0.33333333);
1887 CHECK(buffer == "0.33");
1888
1889 buffer = jau::format_string("%.*e", 2, 0.33333333);
1890 CHECK(buffer == "3.33e-01");
1891}
basic_types.hpp
SomeClass::toString
std::string toString() const
Definition test_stringfmt_format.cpp:206
jau::cfmt::Result::argumentCount
constexpr ssize_t argumentCount() const noexcept
Arguments processed.
Definition string_cfmt.hpp:470
jau::cfmt::Result::opts
constexpr const FormatOpts & opts() const noexcept
Last argument FormatOpts (error analysis)
Definition string_cfmt.hpp:476
jau::cfmt::Result::success
constexpr bool success() const noexcept
true if operation was successful, otherwise indicates error
Definition string_cfmt.hpp:467
cpp_lang_util.hpp
cpp_pragma.hpp
float_types.hpp
jau::to_string
std::string_view to_string(const endian_t v) noexcept
Return std::string representation of the given endian.
Definition basic_types.cpp:1169
jau::lb_endian_t::little
@ little
Identifier for little endian, equivalent to endian::little.
Definition byte_util.hpp:285
JAU_MAKE_ENUM_STRING
#define JAU_MAKE_ENUM_STRING(type,...)
Definition enum_util.hpp:576
jau::value
constexpr bool value(const Bool rhs) noexcept
Definition cpp_lang_util.hpp:541
jau::exponent_unbiased
constexpr int32_t exponent_unbiased(float32_t a) noexcept
Extracts the unbiased 8-bit exponent from the given IEEE 754 (IEC 559) float64_t and subtracts 127,...
Definition float_types.hpp:170
jau::significand_raw
constexpr uint32_t significand_raw(float32_t a) noexcept
Extracts the 23-bit significand (fraction, mantissa) from the given IEEE 754 (IEC 559) float32_t.
Definition float_types.hpp:161
jau_format_checkLine
#define jau_format_checkLine(fmt,...)
Macro produces compile time validation using a static_assert against jau::cfmt::check2Line.
Definition string_cfmt.hpp:2105
jau::cfmt::checkLine
consteval_cxx20 int checkLine(std::string_view fmt, const Targs &...) noexcept
Strict compile-time type validation of deduced argument-types against the format string.
Definition string_cfmt.hpp:1795
jau::cfmt::formatR
Result formatR(std::string &s, size_t maxLen, std::string_view fmt, const Targs &...args) noexcept
Strict format with type validation of arguments against the format string, appending to the given des...
Definition string_cfmt.hpp:1656
jau_format_string
#define jau_format_string(fmt,...)
Macro, safely returns a (non-truncated) string according to snprintf() formatting rules using a reser...
Definition string_cfmt.hpp:2030
jau::unsafe::format_string
std::string format_string(const char *format,...) noexcept
Returns a (non-truncated) string according to snprintf() formatting rules and variable number of argu...
Definition basic_types.cpp:645
jau::cfmt::check
consteval_cxx20 ssize_t check(std::string_view fmt, const Targs &...) noexcept
Strict compile-time type validation of deduced argument-types against the format string.
Definition string_cfmt.hpp:1772
jau_format_check
#define jau_format_check(fmt,...)
Macro produces compile time validation using a static_assert against jau::cfmt::check2.
Definition string_cfmt.hpp:2093
jau::cfmt::plength_t::l
@ l
long integer
Definition string_cfmt.hpp:264
jau::cfmt::flags_t::none
@ none
no flag
Definition string_cfmt.hpp:246
jau::cfmt::flags_t::left
@ left
actual flag -, C99
Definition string_cfmt.hpp:250
jau::cfmt::flags_t::plus
@ plus
actual flag +, C99
Definition string_cfmt.hpp:252
int_types.hpp
jau::cfmt
Author: Sven Gothel sgothel@jausoft.com Copyright (c) 2021-2026 Gothel Software e....
Definition string_cfmt.hpp:213
jau::float_literals
Definition float_si_types.hpp:44
jau::int_literals
Definition int_types.hpp:175
jau::format_string
std::string format_string(std::string_view fmt, const Args &...args) noexcept
Safely returns a (non-truncated) string according to snprintf() formatting rules using a reserved str...
Definition string_cfmt.hpp:1986
string_cfmt.hpp
string_literal.hpp
string_util.hpp
test_type1_t::none
@ none
Definition test_enumutil.cpp:21
game_t
game_t
Definition test_stringconv01.cpp:164
game_t::pacman
@ pacman
Definition test_stringconv01.cpp:167
game_t::mrdo
@ mrdo
Definition test_stringconv01.cpp:168
game_t::chess
@ chess
Definition test_stringconv01.cpp:166
plainenum_t
plainenum_t
Definition test_stringconv01.cpp:172
plainenum_t::lala
@ lala
Definition test_stringconv01.cpp:174
plainenum_t::lili
@ lili
Definition test_stringconv01.cpp:175
TEST_CASE
TEST_CASE("parse: width precision from format", "[jau][std::string][jau::cfmt]")
Definition test_stringfmt_format.cpp:45
checkFormat
static void checkFormat(int line, const char *fmt, const Args &...args)
Definition test_stringfmt_format.cpp:192
type_concepts.hpp
type_traits_queries.hpp