Gamp v0.0.7-67-g7798ac4
Gamp: Graphics, Audio, Multimedia and Processing
Loading...
Searching...
No Matches
test_stringfmt_check.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 <sstream>
22#include <string_view>
23#include <type_traits>
24
25#include <jau/basic_types.hpp>
26#include <jau/cpp_lang_util.hpp>
27#include <jau/cpp_pragma.hpp>
28#include <jau/float_types.hpp>
29#include <jau/int_types.hpp>
30#include <jau/string_cfmt.hpp>
31#include <jau/string_literal.hpp>
32#include <jau/string_util.hpp>
33#include <jau/test/catch2_ext.hpp>
34#include <jau/type_concepts.hpp>
35#include <jau/type_traits_queries.hpp>
36#include <jau/debug.hpp>
37
38#ifdef HAS_STD_FORMAT
39 #include <format>
40#endif
41
42using namespace std::literals;
43
44using namespace jau::float_literals;
45
46using namespace jau::int_literals;
47
48static std::string format_snprintf_ffszu64d(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
49 size_t nchars;
50 std::string str;
51 {
52 const size_t bsz = 1024; // including EOS
53 str.reserve(bsz); // incl. EOS
54 str.resize(bsz - 1); // excl. EOS
55
56 nchars = std::snprintf(&str[0], bsz,
57 "format_000a: %f, %f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %d\n",
58 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
59 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
60 i + 1);
61
62 if( nchars < bsz ) {
63 str.resize(nchars);
64 str.shrink_to_fit();
65 return str;
66 }
67 }
68 str.clear(); // error
69 return str;
70}
71
72static std::string format_010a_jaufmtstr(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
73 return jau::format_string("format_010a: %f, %f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %d\n",
74 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
75 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
76 i + 1);
77}
78
79static std::string format_020a_jaufmtstr_n(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
80 return jau::format_string_n(1023, "format_020a: %f, %f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %d\n",
81 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
82 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
83 i + 1);
84}
85
86static std::string format_030a_strstream(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
87 std::ostringstream ss1;
88 ss1 << "format_030a: "
89 << fa + 1.0_f32 << ", "
90 << fb + 1.0_f32 << ", "
91 << sz1 + 1 << ", "
92 << a_u64 + 1_u64 << ", "
93 << i + 1 << "\n";
94 return ss1.str();
95}
96
97#ifdef HAS_STD_FORMAT
98std::string format_040a_stdformat(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
99 return std::format("format_040a: {0}, {1}, {3}, {4}, {5}\n",
100 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, a_u64 + 1_u64, i + 1);
101}
102#endif
103
104static std::string format_000b_vsnprintf(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
105 size_t nchars;
106 std::string str;
107 {
108 const size_t bsz = 1024; // including EOS
109 str.reserve(bsz); // incl. EOS
110 str.resize(bsz - 1); // excl. EOS
111
112 nchars = std::snprintf(&str[0], bsz,
113 "format_000b: %.2f, %2.2f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %03d\n",
114 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
115 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
116 i + 1);
117
118 if( nchars < bsz ) {
119 str.resize(nchars);
120 str.shrink_to_fit();
121 return str;
122 }
123 }
124 str.clear(); // error
125 return str;
126}
127static std::string format_010b_jaufmtstr(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
128 return jau::format_string("format_010b: %.2f, %2.2f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %03d\n",
129 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
130 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
131 i + 1);
132}
133
134static std::string format_020b_jaufmtstr_n(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
135 return jau::format_string_n(1023, "format_020b: %.2f, %2.2f, %zu, %" PRIu64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 ", %03d\n",
136 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1,
137 a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64, a_u64 + 1_u64,
138 i + 1);
139}
140
141static std::string format_030b_strstream(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
142 std::ostringstream ss1;
143 ss1.precision(3);
144 ss1 << "format_030b: "
145 << fa + 1.0_f32 << ", ";
146 ss1.width(3);
147 ss1 << fb + 1.0_f32 << ", "
148 << sz1 + 1 << ", "
149 << a_u64 + 1_u64 << ", ";
150 ss1.width(3);
151 ss1 << i + 1 << "\n";
152 return ss1.str();
153}
154
155#ifdef HAS_STD_FORMAT
156std::string format_040b_stdformat(float fa, float fb, size_t sz1, uint64_t a_u64, int i) {
157 return std::format("format_040b: {0:.2f}, {1:2.2f}, {3}, {4}, {5:03d}\n",
158 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, a_u64 + 1_u64, i + 1);
159}
160#endif
161
162template <typename Func>
163static size_t test_format(const Func func, bool output) {
164 constexpr float fa = 1.1f, fb = 2.2f;
165 constexpr size_t sz1 = 1;
166 constexpr uint64_t sz2 = 2;
167 constexpr int i = 3;
168
169 const std::string s = func(fa, fb, sz1, sz2, i);
170 volatile size_t l = s.length();
171 if( output ) {
172 std::cout << s;
173 }
174 REQUIRE(0 < l);
175 REQUIRE(l < 1024);
176 return l;
177}
178
179static void format_0a() {
180 test_format(format_snprintf_ffszu64d, true);
181 test_format(format_010a_jaufmtstr, true);
182 test_format(format_020a_jaufmtstr_n, true);
183 test_format(format_030a_strstream, true);
184
185#ifdef HAS_STD_FORMAT
186 test_format(format_040a_stdformat, true);
187#endif
188}
189static void format_0b() {
190 test_format(format_000b_vsnprintf, true);
191 test_format(format_010b_jaufmtstr, true);
192 test_format(format_020b_jaufmtstr_n, true);
193 test_format(format_030b_strstream, true);
194
195#ifdef HAS_STD_FORMAT
196 test_format(format_040b_stdformat, true);
197#endif
198}
199
200static void test_refs(const size_t &sz, const int64_t &i64, const float &f) {
201 // references can't be passed as arguments
202 // static_assert( 0 == jau::cfmt::checkLine("lala %zu, %" PRIi64 ", %f", sz, i64, f) );
203 // static_assert( 0 == jau::cfmt::check("lala %zu, %" PRIi64 ", %f", sz, i64, f) );
204 //
205 // however, after removing the reference and feeding it into the check2 variant, it works
206 static_assert( 0 == jau::cfmt::check2Line<std::remove_reference_t<decltype(sz)>,
207 std::remove_reference_t<decltype(i64)>,
208 std::remove_reference_t<decltype(f)>>("lala %zu, %" PRIi64 ", %f") );
209 //
210 // which is what is done in the macros
211 //
212 jau_format_checkLine("lala %zu, %" PRIi64 ", %f", sz, i64, f);
213 jau_format_check("lala %zu, %" PRIi64 ", %f", sz, i64, f);
214}
215
216TEST_CASE("jau::cfmt_10", "[jau][std::string][jau::cfmt]") {
217 char buf[1024];
218 constexpr float fa = 1.123456f, fb = 2.2f;
219 constexpr size_t sz1 = 1;
220 constexpr int64_t v_i64 = 2;
221 constexpr uint64_t v_u64 = 3;
222 constexpr int i = 3;
223 const float *pf = &fa;
224
225 test_refs(sz1, v_i64, fa);
226 {
227 std::string s;
228 jau::cfmt::Result r = jau::cfmt::formatR(s, "lala %d", 2);
229 std::cerr << "XXX: " << __LINE__ << ": " << r << std::endl;
230 REQUIRE( 1 == r.argumentCount() );
231 }
232 { // 'format_check: %.2f, %2.2f, %zu, %lu, %03d'
233 std::string s;
234 jau::cfmt::Result r = jau::cfmt::formatR(s, "format_check: %.2f, %2.2f, %zu, %" PRIi64 ", %" PRIi64 "d, %" PRIi64 "X, %06" PRIu64 "d, %06" PRIu64 "X, %03d\n",
235 fa, fb, sz1, v_i64, v_i64, v_i64, v_u64, v_u64, i);
236 std::cerr << "XXX: " << __LINE__ << ": " << r << std::endl;
237 REQUIRE(9 == r.argumentCount());
238 }
239 {
240 std::string s;
241 jau::cfmt::Result r = jau::cfmt::formatR(s, "lala %d - end", 2);
242 std::cerr << "XXX: " << __LINE__ << ": " << r << std::endl;
243 REQUIRE(1 == r.argumentCount());
244 }
245 {
246 static_assert( 0 == jau::cfmt::checkLine("lala %d", 2) );
247 static_assert( 1 == jau::cfmt::check("lala %d", 2) );
248
249 int i2 = 2;
250 constexpr const bool b2 = jau::cfmt::check("lala %d", i2);
251 static_assert( b2 );
252 }
253 {
254 static_assert(false == std::is_signed_v<const float*>);
255 static_assert(false == std::is_unsigned_v<const float*>);
256
257 static_assert(true == std::is_signed_v<float>);
258 static_assert(false == std::is_unsigned_v<float>);
259 }
260 {
261 using E = int;
262 using T = unsigned int;
263 // using U = std::conditional_t<std::is_unsigned_v<T>, std::make_signed_t<T>, T>; // triggers the instantiating the 'other' case and hence fails
264 using U = typename std::conditional_t<std::is_unsigned_v<T>, std::make_signed<T>, std::type_identity<T>>::type; // NOLINT
265 static_assert( std::is_same_v<T, T> );
266 static_assert( std::is_same_v<E, U> );
267 }
268 {
269 using E = float;
270 using T = float;
271 // using U = std::conditional_t<std::is_unsigned_v<T>, std::make_signed_t<T>, T>; // triggers the instantiating the 'other' case and hence fails
272 using U = typename std::conditional_t<std::is_unsigned_v<T>, std::make_signed<T>, std::type_identity<T>>::type; // NOLINT
273 static_assert( std::is_same_v<T, T> );
274 static_assert( std::is_same_v<E, U> );
275 }
276 {
277 static_assert(0 == jau::cfmt::checkLine(" lala %d", 1));
278 static_assert(0 == jau::cfmt::checkLine(" lala %ld", 1));
279 static_assert(0 == jau::cfmt::checkLine(" lala %zd", 1));
280 static_assert(0 == jau::cfmt::checkLine(" lala %8d", 1));
281 static_assert(0 == jau::cfmt::checkLine(" lala %08d", 1));
282 static_assert(0 == jau::cfmt::checkLine(" lala %08.2d", 1));
283 static_assert(0 == jau::cfmt::checkLine(" %" PRIi64 ", %" PRIi64 ", %08" PRIi64 ".", (int64_t)1, (int64_t)1, (int64_t)1));
284 }
285 {
286 // we support safe signedness conversion
287 static_assert( 1 == jau::cfmt::check(" int -> int %d", 1));
288 static_assert(-1 == jau::cfmt::check("unsigned int -> int %d", (unsigned int)1)); // error: sizeof(unsigned) == sizeof(signed)
289 static_assert( 1 == jau::cfmt::check("unsigned char -> int %d", (unsigned char)1)); // OK: sizeof(unsigned) < sizeof(signed)
290 static_assert( 1 == jau::cfmt::check("unsigned int -> unsigned int %u", (unsigned int)1));
291 static_assert( 1 == jau::cfmt::check(" int -> unsigned int %u", 1)); // OK: +signed -> unsigned
292 static_assert(-1 == jau::cfmt::check(" uint64_t -> int64_t %" PRIi64, (uint64_t)1)); // error: sizeof(unsigned) == sizeof(signed)
293 static_assert( 1 == jau::cfmt::check(" int64_t -> uint64_t %" PRIu64, (int64_t)1)); // OK: +signed -> unsigned
294
295 // given type <= integral target type
296 static_assert( 1 == jau::cfmt::check(" char -> int %d", (char)1)); // OK given type <= integral target type
297 static_assert(-1 == jau::cfmt::check(" char -> int %d", (uint64_t)1)); // ERR given type > integral target type
298 {
299 jau::cfmt::Result res = jau::cfmt::checkR(" error long -> int %d", (long)1);
300 // if( res.error() ) {
301 printf("XXX: sizeof(long) %zu, %s\n", sizeof(long), res.toString().c_str());
302 }
303 if constexpr ( sizeof(long) <= sizeof(int) ) {
304 REQUIRE( 1 == jau::cfmt::check(" OK long(4) -> int %d", (long)1)); // NOLINT(misc-static-assert)
305 } else {
306 REQUIRE(-1 == jau::cfmt::check(" error long(8) -> int %d", (long)1)); // NOLINT(misc-static-assert); error: given type > integral target type
307 }
308
309 static_assert(1 == jau::cfmt::check(" %d", i));
310 static_assert(1 == jau::cfmt::check(" %f", fa));
311 static_assert(1 == jau::cfmt::check(" %zd", (ssize_t)1));
312 static_assert(1 == jau::cfmt::check(" %zu", (size_t)1));
313 static_assert(3 == jau::cfmt::check(" %" PRIi64 ", %" PRIi64 ", %08" PRIi64 ".", (int64_t)1, (int64_t)1, (int64_t)1));
314 static_assert(3 == jau::cfmt::check(" %" PRIi64 ", %" PRIi64 ", %08" PRIi64 ".", v_i64, v_i64, v_i64));
315 static_assert(1 == jau::cfmt::check(" %p", pf));
316 const char* cs1 = "lala";
317 static_assert(1 == jau::cfmt::check(" %s", (const char*)"lala"));
318 static_assert(1 == jau::cfmt::check(" %s", cs1));
319 static_assert(0 == jau::cfmt::checkLine(" %s", cs1));
320 (void)cs1;
321
322 static_assert(0 == jau::cfmt::checkR("Hello World").argumentCount());
323 static_assert(1 == jau::cfmt::checkR("Hello World %d", 1).argumentCount());
324 static_assert(1 == jau::cfmt::checkR("Hello 1 %d", i).argumentCount());
325 static_assert(0 == jau::cfmt::check("Hello World"));
326 static_assert(1 == jau::cfmt::check("Hello World %d", 1));
327 static_assert(1 == jau::cfmt::check("Hello 1 %d", i));
328
329 static_assert(1 == jau::cfmt::checkR("Hello 1 %.2f", fa).argumentCount());
330 static_assert(1 == jau::cfmt::checkR("Hello 1 %.2f - end", fa).argumentCount());
331 static_assert(2 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb).argumentCount());
332 static_assert(3 == jau::cfmt::checkR("Hello 1 %.2f , 2 %2.2f, 3 %zu - end", fa, fb, sz1).argumentCount());
333 static_assert(4 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 " - end", fa, fb, sz1, v_i64).argumentCount());
334 static_assert(5 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d - end", fa, fb, sz1, v_i64, i).argumentCount());
335
336 static_assert(5 == jau::cfmt::checkR("Hello %" PRIi64 ", %" PRIu64 ", %" PRIx64 ", %06" PRIu64 ", %06" PRIx64 "",
337 v_i64, v_u64, v_u64, v_u64, v_u64).argumentCount());
338
339 // static_assert(6 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end", fa, fb, sz1, sz2, i, pf).argumentCount());
340 // static_assert(1 == jau::cfmt::checkR(" %s", "lala").argumentCount());
341
342 static_assert(0 > jau::cfmt::check("Hello World %"));
343 static_assert(0 > jau::cfmt::checkR("Hello World %").argumentCount());
344 static_assert(0 > jau::cfmt::checkR("Hello 1 %d").argumentCount());
345 static_assert(-1 == jau::cfmt::checkR("Hello 1 %d", fa).argumentCount());
346 if constexpr ( sizeof(long) <= 4 ) {
347 assert( 1 == jau::cfmt::checkR("Hello 1 %d", sz1).argumentCount()); // NOLINT(misc-static-assert)
348 } else {
349 assert(-1 == jau::cfmt::checkR("Hello 1 %d", sz1).argumentCount()); // NOLINT(misc-static-assert)
350 }
351 static_assert(-6 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end",
352 fa, fb, sz1, v_i64, i, i).argumentCount());
353 static_assert(-6 == jau::cfmt::check("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end",
354 fa, fb, sz1, v_i64, i, i));
355
356 {
357 static_assert(0 <= jau::cfmt::checkR("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
358 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, v_i64 + 1_u64, i + 1).argumentCount()); // compile time validation!
359 const std::string s = jau_format_string("format_020a: %f, %f, %zu, %" PRIu64 ", %d\n",
360 fa + 1.0_f32, fb + 1.0_f32, sz1 + 1, v_i64 + 1_u64, i + 1);
361 REQUIRE( s.size() > 0 );
362 }
363 {
364 std::string s0 = jau::format_string("Hello %d", 1);
365 REQUIRE( s0.size() > 0 );
366 // FIXME
367 // const std::string s1 = jau::format_string<"Hello %d">(1);
368 // REQUIRE_THROWS_AS( s0 = jau::format_string("Hello %d", 1.0f), jau::IllegalArgumentError);
369 }
370 }
371 {
372 std::string s1 = jau_format_string("Hello %d", 1);
373 REQUIRE("Hello 1" == s1);
374
375 constexpr jau::cfmt::Result c1 = jau::cfmt::checkR("Hello %u", (unsigned int)1);
376 std::cerr << "XXX: " << __LINE__ << ": " << c1 << std::endl;
377 REQUIRE(true == c1.success());
378 }
379 {
380 constexpr jau::cfmt::Result c1 = jau::cfmt::checkR("Hello World");
381 REQUIRE(true == c1.success());
382 REQUIRE(0 == c1.argumentCount());
383 REQUIRE(0 == jau::cfmt::checkR("Hello World").argumentCount());
384 constexpr jau::cfmt::Result c3 = jau::cfmt::checkR("Hello 1 %d", i);
385 REQUIRE(true == c3.success());
386 REQUIRE(1 == c3.argumentCount());
387 REQUIRE(9 == std::snprintf(buf, sizeof(buf), "Hello 1 %d", i));
388
389 // `Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %li, 5 %03d, 6 %p - end`
390 REQUIRE(1 == jau::cfmt::checkR("Hello 1 %.2f", fa).argumentCount());
391 REQUIRE(1 == jau::cfmt::checkR("Hello 1 %.2f - end", fa).argumentCount());
392
393 // 'Hello 1 %.2f, 2 %2.2f - end'
394 jau::cfmt::Result pc = jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb);
395 std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;
396 REQUIRE(2 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f - end", fa, fb).argumentCount());
397
398 // `Hello 1 %.2f, 2 %2.2f, 3 %zu - end`
399 pc = jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu - end", fa, fb, sz1);
400 std::cerr << "XXX: " << __LINE__ << ": " << pc << std::endl;
401 REQUIRE(3 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu - end", fa, fb, sz1).argumentCount());
402
403 REQUIRE(4 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 " - end", fa, fb, sz1, v_i64).argumentCount());
404 REQUIRE(5 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d - end", fa, fb, sz1, v_i64, i).argumentCount());
405 REQUIRE(6 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end", fa, fb, sz1, v_i64, i, pf).argumentCount());
406
407 // REQUIRE(13 == std::snprintf(buf, sizeof(buf), "Hello World %").argumentCount());
408 REQUIRE(0 > jau::cfmt::checkR("Hello World %").argumentCount());
409 REQUIRE(0 > jau::cfmt::checkR("Hello 1 %d").argumentCount());
410 REQUIRE(-1 == jau::cfmt::checkR("Hello 1 %d", fa).argumentCount());
411 if constexpr ( sizeof(long) <= 4 ) {
412 REQUIRE( 1 == jau::cfmt::checkR("Hello 1 %d", sz1).argumentCount());
413 } else {
414 REQUIRE(-1 == jau::cfmt::checkR("Hello 1 %d", sz1).argumentCount());
415 }
416 REQUIRE(-6 == jau::cfmt::checkR("Hello 1 %.2f, 2 %2.2f, 3 %zu, 4 %" PRIi64 ", 5 %03d, 6 %p - end",
417 fa, fb, sz1, v_i64, i, i).argumentCount());
418 }
419}
420
421TEST_CASE("jau::cfmt_01", "[jau][std::string][format_string]") {
422 format_0a();
423 format_0b();
424}
425
426TEST_CASE("jau::cfmt_10 debug", "[jau][std::string][format_string][debug]") {
427 jau_INFO_PRINT("lala001");
428 jau_INFO_PRINT("lala002 %d, %f, %s", 1, 3.14, "hello world");
429 std::string s1 = "Hello";
430 std::string_view sv1 = s1;
431 const char * s1p = s1.c_str();
432 jau_INFO_PRINT("lala003 %s, %s, %s", s1, sv1, s1p);
433
434 jau_ERR_PRINT3("error 01: '%s', %d", s1, 88);
435}
basic_types.hpp
jau::cfmt::Result::argumentCount
constexpr ssize_t argumentCount() const noexcept
Arguments processed.
Definition string_cfmt.hpp:454
jau::cfmt::Result::toString
std::string toString() const
Definition basic_types.cpp:1372
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
jau_INFO_PRINT
#define jau_INFO_PRINT(fmt,...)
Use for unconditional informal messages, prefix '[elapsed_time] Info: '.
Definition debug.hpp:165
jau_ERR_PRINT3
#define jau_ERR_PRINT3(...)
Use for unconditional error messages, prefix '[elapsed_time] Error @ FILE:LINE FUNC: '.
Definition debug.hpp:156
float_types.hpp
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::cfmt::checkR
consteval_cxx20 Result checkR(std::string_view fmt, const Targs &...) noexcept
Strict compile-time type validation of deduced argument-types against the format string.
Definition string_cfmt.hpp:1811
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::cfmt::check2Line
consteval_cxx20 int check2Line(std::string_view fmt) noexcept
Strict compile-time type validation of explicit argument-types against the format string.
Definition string_cfmt.hpp:1790
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
int_types.hpp
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
jau::format_string_n
std::string format_string_n(const std::size_t maxLen, std::string_view fmt, const Args &...args) noexcept
Safely returns a (potentially truncated) string according to snprintf() formatting rules and variable...
Definition string_cfmt.hpp:1862
string_cfmt.hpp
string_literal.hpp
string_util.hpp
jau::type
f
static std::string f(uint32_t v)
Definition test_basictypeconv.cpp:102
printf
int printf(const char *format,...)
Operating Systems predefined macros.
test_format
static size_t test_format(const Func func, bool output)
Definition test_stringfmt_check.cpp:163
test_refs
static void test_refs(const size_t &sz, const int64_t &i64, const float &f)
Definition test_stringfmt_check.cpp:200
format_020b_jaufmtstr_n
static std::string format_020b_jaufmtstr_n(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:134
format_0b
static void format_0b()
Definition test_stringfmt_check.cpp:189
format_snprintf_ffszu64d
static std::string format_snprintf_ffszu64d(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:48
format_010a_jaufmtstr
static std::string format_010a_jaufmtstr(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:72
format_0a
static void format_0a()
Definition test_stringfmt_check.cpp:179
TEST_CASE
TEST_CASE("jau::cfmt_10", "[jau][std::string][jau::cfmt]")
Definition test_stringfmt_check.cpp:216
format_000b_vsnprintf
static std::string format_000b_vsnprintf(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:104
format_020a_jaufmtstr_n
static std::string format_020a_jaufmtstr_n(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:79
format_030a_strstream
static std::string format_030a_strstream(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:86
format_030b_strstream
static std::string format_030b_strstream(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:141
format_010b_jaufmtstr
static std::string format_010b_jaufmtstr(float fa, float fb, size_t sz1, uint64_t a_u64, int i)
Definition test_stringfmt_check.cpp:127
type_concepts.hpp
type_traits_queries.hpp