This C++ unit test validates most of the supported format specifiers against its arguments.
This C++ unit test validates most of the supported format specifiers against its arguments.
#include <sys/types.h>
#include <cassert>
#include <cinttypes>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string_view>
#include <jau/test/catch2_ext.hpp>
#ifdef HAS_STD_FORMAT
#include <format>
#endif
using namespace std::literals;
TEST_CASE(
"parse: width precision from format",
"[jau][std::string][jau::cfmt]") {
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
}
}
TEST_CASE(
"parse: width precision from arg",
"[jau][std::string][jau::cfmt]") {
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
REQUIRE( true == r.success());
REQUIRE( 2 == r.argumentCount());
REQUIRE( true == r.opts().width_set);
REQUIRE( 21 == r.opts().width);
REQUIRE( false == r.opts().precision_set);
REQUIRE( 0 == r.opts().precision);
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
REQUIRE( true == r.success());
REQUIRE( 2 == r.argumentCount());
REQUIRE( false == r.opts().width_set);
REQUIRE( 0 == r.opts().width);
REQUIRE( true == r.opts().precision_set);
REQUIRE( 12 == r.opts().precision);
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
REQUIRE( true == r.success());
REQUIRE( 3 == r.argumentCount());
REQUIRE( true == r.opts().width_set);
REQUIRE( 23 == r.opts().width);
REQUIRE( true == r.opts().precision_set);
REQUIRE( 12 == r.opts().precision);
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
REQUIRE( true == r.success());
REQUIRE( 2 == r.argumentCount());
REQUIRE( true == r.opts().width_set);
REQUIRE( 23 == r.opts().width);
REQUIRE( true == r.opts().precision_set);
REQUIRE( 12 == r.opts().precision);
}
{
std::string s;
std::cerr << "FormatResult " << r << "\n";
REQUIRE( true == r.success());
REQUIRE( 2 == r.argumentCount());
REQUIRE( false == r.opts().width_set);
REQUIRE( 0 == r.opts().width);
REQUIRE( true == r.opts().precision_set);
REQUIRE( 12 == r.opts().precision);
}
}
template <typename... Args>
static void checkFormat(
int line,
const char *fmt,
const Args &...args) {
std::string has;
std::cerr << "FormatResult @ " << line << ": " << r << "\n";
std::cerr << "FormatResult @ " << line << ": exp `" << exp << "`, has `" << has << "`\n\n";
CHECK(exp == has);
}
TEST_CASE(
"single_conversion",
"[jau][std::string][jau::cfmt]") {
int32_t i32 = -1234;
int32_t i32_u = 1234;
uint32_t u32 = 1234;
float f32 = 123.45f;
double f64 = 123.45;
void *p1a = (void *)0xaabbccdd_u64;
void *p1b = (void *)0x11223344aabbccdd_u64;
void *p2a = (void *)0x112233aabbccdd_u64;
void *p2b = (void *)0xaabbcc_u64;
void *p3a = (void *)0x112233aabbccdd_u64;
void *p3b = (void *)0xaabbcc_u64;
const char sl1[] = "Hallo";
std::string s2 = "World";
std::string_view s2sv = s2;
const char *s2p = s2.c_str();
{
const int expval = std::ilogb(
value);
const double frac =
value / std::scalbn(1.0, expval);
fprintf(stderr,
"JAU:10 v %f = %f * 2^%d -> 0x%0" PRIx64
"p%d\n",
value, frac, expval, significand, expval);
fprintf(stderr,
"JAU:11 v %f = %f * 2^%d -> 0x%0" PRIx64
"p%d\n",
value, frac, expval2, significand, expval2);
}
{
const int expval = std::ilogb(
value);
const double frac =
value / std::scalbn(1.0, expval);
fprintf(stderr,
"JAU:20 v %f = %f * 2^%d -> 0x%0" PRIx32
"p%d\n",
value, frac, expval, significand, expval);
fprintf(stderr,
"JAU:21 v %f = %f * 2^%d -> 0x%0" PRIx32
"p%d\n",
value, frac, expval2, significand, expval2);
}
{
float ivalue = 123.45f;
const int expval = std::ilogb(
value);
const double frac =
value / std::scalbn(1.0, expval);
fprintf(stderr,
"JAU:30 v %f = %f * 2^%d -> 0x%0" PRIx64
"p%d\n",
value, frac, expval, significand, expval);
fprintf(stderr,
"JAU:31 v %f = %f * 2^%d -> 0x%0" PRIx64
"p%d\n",
value, frac, expval2, significand, expval2);
}
{
}
{
const char *str = nullptr;
size_t str_len = 2;
const char limiter = '3';
const char *limiter_pos = nullptr;
char *endptr = nullptr;
jau_string_check(
"Value end not '%c' @ idx %zd, %p != %p, in: %p '%s' len %zu", limiter, endptr - str, endptr, limiter_pos, str, str, str_len);
jau_string_checkLine(
"Value end not '%c' @ idx %zd, %p != %p, in: %p '%s' len %zu", limiter, endptr - str, endptr, limiter_pos, str, str, str_len);
}
{
}
{
enum enum1_unsigned_t { jau1_alpha, jau1_beta, jau1_gamma };
enum1_unsigned_t e1_u = jau1_alpha;
enum enum2_signed_t { jau2_alpha=-1, jau_beta, jau_gamma };
enum2_signed_t e2_s = jau2_alpha;
enum class enum3_signed_t { alpha=-1, beta, gamma };
enum3_signed_t e3_s = enum3_signed_t::alpha;
typedef enum {
jau_CAP_CLEAR=0,
jau_CAP_SET=1
} enum4_unsigned_t;
enum4_unsigned_t e4_u = jau_CAP_CLEAR;
static_assert(true == std::is_enum_v<decltype(e1_u)>);
static_assert(true == std::is_unsigned_v<std::underlying_type_t<decltype(e1_u)>>);
static_assert(true == std::is_enum_v<decltype(e2_s)>);
static_assert(true == std::is_signed_v<std::underlying_type_t<decltype(e2_s)>>);
static_assert(true == std::is_enum_v<decltype(e3_s)>);
static_assert(true == std::is_signed_v<std::underlying_type_t<decltype(e3_s)>>);
static_assert(true == std::is_enum_v<decltype(e4_u)>);
static_assert(true == std::is_unsigned_v<std::underlying_type_t<decltype(e4_u)>>);
static_assert(4 ==
jau::cfmt::check(
"%u, %d, %d, %u\n", e1_u, e2_s, e3_s, e4_u));
}
}
TEST_CASE(
"thousands_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
}
TEST_CASE(
"binary",
"[jau][std::string][jau::cfmt][flags]" ) {
}
TEST_CASE(
"space_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
std::string buffer;
CHECK(buffer == " 42");
CHECK(buffer == "-42");
CHECK(buffer == " 42");
CHECK(buffer == " -42");
CHECK(buffer == " 42");
CHECK(buffer == " -42");
CHECK(buffer == " -42");
CHECK(buffer == " -42.987");
CHECK(buffer == " 42.987");
CHECK(buffer == "Hello testing");
CHECK(buffer == " 1024");
CHECK(buffer == "-1024");
CHECK(buffer == " 1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "4294966272");
CHECK(buffer == "777");
CHECK(buffer == "37777777001");
CHECK(buffer == "1234abcd");
CHECK(buffer == "edcb5433");
CHECK(buffer == "1234ABCD");
CHECK(buffer == "EDCB5433");
CHECK(buffer == "x");
}
TEST_CASE(
"plus_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
std::string buffer;
CHECK(buffer == "+42");
CHECK(buffer == "-42");
CHECK(buffer == " +42");
CHECK(buffer == " -42");
CHECK(buffer == " +42");
CHECK(buffer == " -42");
CHECK(buffer == "Hello testing");
CHECK(buffer == "+1024");
CHECK(buffer == "-1024");
CHECK(buffer == "+1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "4294966272");
CHECK(buffer == "777");
CHECK(buffer == "37777777001");
CHECK(buffer == "1234abcd");
CHECK(buffer == "edcb5433");
CHECK(buffer == "1234ABCD");
CHECK(buffer == "EDCB5433");
CHECK(buffer == "x");
CHECK(buffer == "+");
}
TEST_CASE(
"zero_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
std::string buffer;
CHECK(buffer == "42");
CHECK(buffer == "42");
CHECK(buffer == "-42");
CHECK(buffer == "00042");
CHECK(buffer == "-0042");
CHECK(buffer == "000000000000042");
CHECK(buffer == "-00000000000042");
CHECK(buffer == "000000000042.12");
CHECK(buffer == "00000000042.988");
CHECK(buffer == "-00000042.98760");
}
TEST_CASE(
"left_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
std::string buffer;
CHECK(buffer == "42");
CHECK(buffer == "-42");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "42");
CHECK(buffer == "-42");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "42");
CHECK(buffer == "-42");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "42 ");
CHECK(buffer == "-42 ");
CHECK(buffer == "-4.200e+01 ");
CHECK(buffer == "-42.0 ");
}
TEST_CASE(
"hash_flag",
"[jau][std::string][jau::cfmt][flags]" ) {
std::string buffer;
CHECK(buffer == "");
CHECK(buffer == "0");
CHECK(buffer == "");
CHECK(buffer == "0x0000614e");
CHECK(buffer == "0b110");
}
TEST_CASE(
"specifier",
"[jau][std::string][jau::cfmt][specifier]" ) {
std::string buffer;
CHECK(buffer == "Hello testing");
CHECK(buffer == "Hello testing");
CHECK(buffer == "1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "4294966272");
CHECK(buffer == "777");
CHECK(buffer == "37777777001");
CHECK(buffer == "1234abcd");
CHECK(buffer == "edcb5433");
CHECK(buffer == "1234ABCD");
CHECK(buffer == "EDCB5433");
CHECK(buffer == "%");
}
TEST_CASE(
"width",
"[jau][std::string][jau::cfmt][width]" ) {
std::string buffer;
CHECK(buffer == "Hello testing");
CHECK(buffer == "1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "-1024");
CHECK(buffer == "1024");
CHECK(buffer == "4294966272");
CHECK(buffer == "777");
CHECK(buffer == "37777777001");
CHECK(buffer == "1234abcd");
CHECK(buffer == "edcb5433");
CHECK(buffer == "1234ABCD");
CHECK(buffer == "EDCB5433");
CHECK(buffer == "x");
}
TEST_CASE(
"width_20",
"[jau][std::string][jau::cfmt][width]" ) {
std::string buffer;
CHECK(buffer == " Hello");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " 4294966272");
CHECK(buffer == " 777");
CHECK(buffer == " 37777777001");
CHECK(buffer == " 1234abcd");
CHECK(buffer == " edcb5433");
CHECK(buffer == " 1234ABCD");
CHECK(buffer == " EDCB5433");
CHECK(buffer == " x");
}
TEST_CASE(
"width_star_20",
"[jau][std::string][jau::cfmt][width]" ) {
std::string buffer;
CHECK(buffer == " Hello");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " 4294966272");
CHECK(buffer == " 777");
CHECK(buffer == " 37777777001");
CHECK(buffer == " 1234abcd");
CHECK(buffer == " edcb5433");
CHECK(buffer == " 1234ABCD");
CHECK(buffer == " EDCB5433");
CHECK(buffer == " x");
}
TEST_CASE(
"width_left_20",
"[jau][std::string][jau::cfmt][width]" ) {
std::string buffer;
CHECK(buffer == "Hello ");
CHECK(buffer == "1024 ");
CHECK(buffer == "-1024 ");
CHECK(buffer == "1024 ");
CHECK(buffer == "-1024 ");
CHECK(buffer == "1024 ");
CHECK(buffer == "1024.1234 ");
CHECK(buffer == "4294966272 ");
CHECK(buffer == "777 ");
CHECK(buffer == "37777777001 ");
CHECK(buffer == "1234abcd ");
CHECK(buffer == "edcb5433 ");
CHECK(buffer == "1234ABCD ");
CHECK(buffer == "EDCB5433 ");
CHECK(buffer == "x ");
CHECK(buffer == "| 9| |9 | | 9|");
CHECK(buffer == "| 10| |10| | 10|");
CHECK(buffer == "| 9| |9 | | 9|");
CHECK(buffer == "| 10| |10 | | 10|");
}
TEST_CASE(
"zero_width_left_20",
"[jau][std::string][jau::cfmt][width]" ) {
std::string buffer;
CHECK(buffer == "Hello ");
CHECK(buffer == "1024 ");
CHECK(buffer == "-1024 ");
CHECK(buffer == "1024 ");
CHECK(buffer == "-1024 ");
CHECK(buffer == "1024 ");
CHECK(buffer == "4294966272 ");
CHECK(buffer == "777 ");
CHECK(buffer == "37777777001 ");
CHECK(buffer == "1234abcd ");
CHECK(buffer == "edcb5433 ");
CHECK(buffer == "1234ABCD ");
CHECK(buffer == "EDCB5433 ");
CHECK(buffer == "x ");
}
TEST_CASE(
"width_20",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-0000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-0000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "00000000004294966272");
CHECK(buffer == "00000000000000000777");
CHECK(buffer == "00000000037777777001");
CHECK(buffer == "0000000000001234abcd");
CHECK(buffer == "000000000000edcb5433");
CHECK(buffer == "0000000000001234ABCD");
CHECK(buffer == "000000000000EDCB5433");
}
TEST_CASE(
"precision_20",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-00000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-00000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "00000000004294966272");
CHECK(buffer == "00000000000000000777");
CHECK(buffer == "00000000037777777001");
CHECK(buffer == "0000000000001234abcd");
CHECK(buffer == "000000000000edcb5433");
CHECK(buffer == "0000000000001234ABCD");
CHECK(buffer == "000000000000EDCB5433");
}
TEST_CASE(
"hash_zero_width_20",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-0000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "-0000000000000001024");
CHECK(buffer == "00000000000000001024");
CHECK(buffer == "00000000004294966272");
CHECK(buffer == "00000000000000000777");
CHECK(buffer == "00000000037777777001");
CHECK(buffer == "0x00000000001234abcd");
CHECK(buffer == "0x0000000000edcb5433");
CHECK(buffer == "0X00000000001234ABCD");
CHECK(buffer == "0X0000000000EDCB5433");
}
TEST_CASE(
"hash_width_20",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " 1024");
CHECK(buffer == " 4294966272");
CHECK(buffer == " 0777");
CHECK(buffer == " 037777777001");
CHECK(buffer == " 0x1234abcd");
CHECK(buffer == " 0xedcb5433");
CHECK(buffer == " 0X1234ABCD");
CHECK(buffer == " 0XEDCB5433");
}
TEST_CASE(
"width_20_precision_5",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == " 01024");
CHECK(buffer == " -01024");
CHECK(buffer == " 01024");
CHECK(buffer == " -01024");
CHECK(buffer == " 01024");
CHECK(buffer == " 4294966272");
CHECK(buffer == " 00777");
CHECK(buffer == " 37777777001");
CHECK(buffer == " 1234abcd");
CHECK(buffer == " 00edcb5433");
CHECK(buffer == " 1234ABCD");
CHECK(buffer == " 00EDCB5433");
}
TEST_CASE(
"padding neg_numbers",
"[jau][std::string][jau::cfmt][padding]" ) {
std::string buffer;
CHECK(buffer == "-5");
CHECK(buffer == "-5");
CHECK(buffer == " -5");
CHECK(buffer == " -5");
CHECK(buffer == "-5");
CHECK(buffer == "-5");
CHECK(buffer == "-05");
CHECK(buffer == "-005");
}
TEST_CASE(
"float padding_neg_numbers",
"[jau][std::string][jau::cfmt][float]" ) {
std::string buffer;
CHECK(buffer == "-5.0");
CHECK(buffer == "-5.0");
CHECK(buffer == " -5.0");
CHECK(buffer == " -5");
CHECK(buffer == "-5.0e+00");
CHECK(buffer == " -5.0e+00");
CHECK(buffer == "-5.0");
CHECK(buffer == "-5.0");
CHECK(buffer == "-05.0");
CHECK(buffer == "-5");
CHECK(buffer == "-5");
CHECK(buffer == "-05");
CHECK(buffer == "-005.0e+00");
CHECK(buffer == "-05E+00");
CHECK(buffer == "-05");
}
TEST_CASE(
"length",
"[jau][std::string][jau::cfmt][length]" ) {
std::string buffer;
CHECK(buffer == "");
CHECK(buffer == " ");
CHECK(buffer == "");
CHECK(buffer == " ");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " ");
CHECK(buffer == " 1024");
CHECK(buffer == " -1024");
CHECK(buffer == " ");
CHECK(buffer == " 1024");
CHECK(buffer == " 4294966272");
CHECK(buffer == " ");
CHECK(buffer == " 777");
CHECK(buffer == " 37777777001");
CHECK(buffer == " ");
CHECK(buffer == " 1234abcd");
CHECK(buffer == " 1234abcd");
CHECK(buffer == " 1234abcd 12345");
CHECK(buffer == " edcb5433");
CHECK(buffer == " ");
CHECK(buffer == " 1234ABCD");
CHECK(buffer == " EDCB5433");
CHECK(buffer == " ");
CHECK(buffer == " ");
CHECK(buffer == " ");
}
TEST_CASE(
"float",
"[jau][std::string][jau::cfmt][float]" ) {
std::string buffer;
CHECK(buffer == " nan");
CHECK(buffer == " inf");
CHECK(buffer == "-inf ");
CHECK(buffer == " +inf");
CHECK(buffer == "3.1415");
CHECK(buffer == "30343.142");
CHECK(buffer == "34");
CHECK(buffer == "1");
CHECK(buffer == "2");
CHECK(buffer == "1.6");
CHECK(buffer == "42.90");
CHECK(buffer == "42.895200000");
CHECK(buffer == "42.8952230000");
CHECK(buffer == "42.987654321098");
CHECK(buffer == "42.987654321099");
CHECK(buffer == "42.98765432109876");
CHECK(buffer == "42.98765432109877");
CHECK(buffer == "42.9876543210987600");
CHECK(buffer == "42.9876543210987700");
CHECK(buffer == " 42.90");
CHECK(buffer == "+42.90");
CHECK(buffer == "+42.9");
CHECK(buffer == "42.500000");
CHECK(buffer == "42.5");
CHECK(buffer == "42167.000000");
CHECK(buffer == "-12345.987654321");
CHECK(buffer == "4.0");
CHECK(buffer == "4");
CHECK(buffer == "4");
CHECK(buffer == "3");
CHECK(buffer == "3.5");
CHECK(buffer == "a0.5 ");
CHECK(buffer == "a0.5 end");
CHECK(buffer == "12345.7");
CHECK(buffer == "12345.68");
CHECK(buffer == "1.2346E+08");
CHECK(buffer == "12345.0");
CHECK(buffer == " +1.235e+08");
CHECK(buffer == "0.0012");
CHECK(buffer == " +0.001234");
CHECK(buffer == "+001.234e-05");
CHECK(buffer == "-1.23e-308");
CHECK(buffer == "+1.230E+308");
CHECK(buffer == "1.0e+20");
CHECK(buffer == "-1.12345");
CHECK(buffer == "-1.00000e+20");
bool fail = false;
std::stringstream str;
str.precision(5);
for (float i = -100000; i < 100000; i += 1) {
str.str("");
str << std::fixed << i / 10000;
fail = fail || buffer != str.str();
}
CHECK(!fail);
fail = false;
str.setf(std::ios::scientific, std::ios::floatfield);
for (float i = -1e20; i < 1e20; i += 1e15) {
buffer.shrink_to_fit();
str.str("");
str << i;
REQUIRE(buffer == str.str());
fail = fail || buffer != str.str();
}
CHECK(!fail);
}
TEST_CASE(
"types",
"[jau][std::string][jau::cfmt][types]" ) {
std::string buffer;
CHECK(buffer == "0");
CHECK(buffer == "1234");
CHECK(buffer == "32767");
CHECK(buffer == "-32767");
CHECK(buffer == "30");
CHECK(buffer == "-2147483647");
CHECK(buffer == "2147483647");
CHECK(buffer == "30");
CHECK(buffer == "-9223372036854775807");
CHECK(buffer == "9223372036854775807");
CHECK(buffer == "100000");
CHECK(buffer == "4294967295");
CHECK(buffer == "281474976710656");
CHECK(buffer == "18446744073709551615");
CHECK(buffer == "2147483647");
CHECK(buffer == "2147483647");
if (sizeof(size_t) == sizeof(long)) {
CHECK(buffer == "-2147483647");
}
else {
CHECK(buffer == "-2147483647");
}
CHECK(buffer == "1110101001100000");
CHECK(buffer == "101111000110000101001110");
CHECK(buffer == "165140");
CHECK(buffer == "57060516");
CHECK(buffer == "12345678");
CHECK(buffer == "1234567891234567");
CHECK(buffer == "abcdefab");
CHECK(buffer == "ABCDEFAB");
CHECK(buffer == "v");
CHECK(buffer == "wv");
CHECK(buffer == "A Test");
CHECK(buffer == "255");
CHECK(buffer == "4660");
CHECK(buffer == "Test16 65535");
CHECK(buffer == "a");
if (sizeof(intmax_t) == sizeof(long)) {
CHECK(buffer == "-2147483647");
}
else {
CHECK(buffer == "-2147483647");
}
}
TEST_CASE(
"pointer",
"[jau][std::string][jau::cfmt][pointer]" ) {
std::string buffer;
#if 0
if (sizeof(void*) == 4U) {
CHECK(buffer == "00001234");
}
else {
CHECK(buffer == "0000000000001234");
}
if (sizeof(void*) == 4U) {
CHECK(buffer == "12345678");
}
else {
CHECK(buffer == "0000000012345678");
}
if (sizeof(void*) == 4U) {
CHECK(buffer == "12345678-7EDCBA98");
}
else {
CHECK(buffer == "0000000012345678-000000007EDCBA98");
}
if (sizeof(uintptr_t) == sizeof(uint64_t)) {
CHECK(buffer == "00000000FFFFFFFF");
}
else {
CHECK(buffer == "FFFFFFFF");
}
#else
CHECK(buffer == "0x1234");
CHECK(buffer == "0x12345678");
CHECK(buffer == "0x12345678-0x7edcba98");
CHECK(buffer == "0xffffffff");
#endif
}
TEST_CASE(
"unknown flag",
"[jau][std::string][jau::cfmt][error]" ) {
std::string buffer;
const size_t q = buffer.find("<E#", 0);
CHECK( q != std::string::npos );
}
TEST_CASE(
"string length",
"[jau][std::string][jau::cfmt][stringlen]" ) {
std::string buffer;
CHECK(buffer == "This");
CHECK(buffer == "test");
CHECK(buffer == "123");
CHECK(buffer == "");
CHECK(buffer == "1234ab");
const size_t q = buffer.find("<E#", 0);
CHECK( q != std::string::npos );
CHECK(buffer == "123");
}
TEST_CASE(
"misc",
"[jau][std::string][jau::cfmt][misc]" ) {
std::string buffer;
CHECK(buffer == "53000atest-20 bit");
CHECK(buffer == "0.33");
CHECK(buffer == "1");
CHECK(buffer == "foo");
CHECK(buffer == " ");
CHECK(buffer == " 00004");
CHECK(buffer == "hi x");
CHECK(buffer == "0.33");
CHECK(buffer == "3.33e-01");
}
constexpr ssize_t argumentCount() const noexcept
Arguments processed.
constexpr const FormatOpts & opts() const noexcept
Last argument FormatOpts (error analysis)
constexpr bool success() const noexcept
true if operation was successful, otherwise indicates error
constexpr bool value(const Bool rhs) noexcept
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,...
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.
Result formatR(std::string &s, std::string_view fmt, const Targs &...args) noexcept
Strict format with type validation of arguments against the format string, appending to the given des...
#define jau_string_check(fmt,...)
Macro produces compile time validation using a static_assert against jau::cfmt::check2.
#define jau_string_checkLine(fmt,...)
Macro produces compile time validation using a static_assert against jau::cfmt::check2Line.
consteval_cxx20 int checkLine(std::string_view fmt, const Targs &...) noexcept
Strict type validation of arguments against the format string.
#define jau_format_string(fmt,...)
Macro, safely returns a (non-truncated) string according to snprintf() formatting rules using a reser...
consteval_cxx20 ssize_t check(std::string_view fmt, const Targs &...) noexcept
Strict type validation of arguments against the format string.
Author: Sven Gothel sgothel@jausoft.com Copyright (c) 2021-2026 Gothel Software e....
std::string format_string(const char *format,...) noexcept
Returns a (non-truncated) string according to snprintf() formatting rules and variable number of argu...
std::string format_string(std::string_view format, const Args &...args) noexcept
Safely returns a (non-truncated) string according to snprintf() formatting rules using a reserved str...
TEST_CASE("Endianess Test 00", "[endian]")
1.13.2