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