Merge pull request 'feature/int_hex' (#6) from feature/int_hex into master

Reviewed-on: http://git.mercurial-manifold.eu/an.tsouchlos/const_fmt/pulls/6

LICENSE

@@ -0,0 +1,19 @@
+Copyright 2022 Andreas Tsouchlos
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

const_fmt/format.h

@@ -2,8 +2,6 @@
 #define LOGGER_FORMAT_H
 
 
-#include <cstring>
-
 #include "format_impl.h"
 #include "parse.h"
 #include "utility.h"
@@ -42,12 +40,12 @@ constexpr inline void check_fmt_params() {
 
 template <fmt_data_t fmt_data, std::integral arg_t>
 constexpr inline void format_arg(char* dest, arg_t arg) {
-    const_fmt_detail::format_int(dest, arg, fmt_data);
+    const_fmt_detail::format_int<fmt_data>(dest, arg);
 };
 
 template <fmt_data_t fmt_data, std::floating_point arg_t>
 constexpr inline void format_arg(char* dest, arg_t arg){
-    // const_fmt_detail::format_float(dest, arg, fmt_data);
+    const_fmt_detail::format_float<fmt_data>(dest, arg);
 };
 
 // TODO: Error handling
@@ -93,7 +91,6 @@ consteval inline auto get_preproc_string() {
         } else {
             for (int j = 0; j < ast_node.get_node().length; ++j)
                 result[i++] = ast_node.get_node().has_zero_padding ? '0' : ' ';
-                //i += ast_node.get_node().length;
         }
     }
 
@@ -116,10 +113,12 @@ namespace const_fmt {
 
 template <const_fmt_detail::ConstString s, typename... args_t>
 constexpr inline auto const_format(args_t... args) {
-    constexpr auto ast      = const_fmt_detail::parse_string<s>().value;
-    constexpr auto fmt_data = const_fmt_detail::get_fmt_data<ast>();
+    constexpr auto ast      = const_fmt_detail::parse_string<s>();
+    constexpr auto fmt_data = const_fmt_detail::get_fmt_data<ast.value>();
 
-    auto result = const_fmt_detail::get_preproc_string<ast>();
+    static_assert(ast.is_valid, "Invalid format string");
+
+    auto result = const_fmt_detail::get_preproc_string<ast.value>();
 
     const_fmt_detail::format_args<fmt_data>(result.begin(), args...);
 

const_fmt/format_impl.h

@@ -10,8 +10,7 @@
  *
  */
 
-
-#include <cstdint>
+#include <stdint.h>
 
 #include "utility.h"
 
@@ -32,7 +31,7 @@ namespace const_fmt { namespace const_fmt_detail {
         (factor)*1000000000
 
 template <typename T>
-constexpr int count_digits_fallback(T n) {
+constexpr int count_digits_decimal_fallback(T n) {
     int count = 1;
     for (;;) {
         if (n < 10) return count;
@@ -44,7 +43,7 @@ constexpr int count_digits_fallback(T n) {
     }
 }
 
-inline int do_count_digits(uint64_t n) {
+inline int do_count_digits_decimal(uint64_t n) {
     // Maps bsr(n) to ceil(log10(pow(2, bsr(n) + 1) - 1)).
     static constexpr uint8_t bsr2log10[] = {
         1,  1,  1,  2,  2,  2,  3,  3,  3,  4,  4,  4,  4,  5,  5,  5,
@@ -58,22 +57,63 @@ inline int do_count_digits(uint64_t n) {
     return t - (n < zero_or_powers_of_10[t]);
 }
 
-constexpr inline auto count_digits(uint64_t n) -> int {
-    if (!std::is_constant_evaluated()) {
-        return do_count_digits(n);
+template <FormatType t_format_type>
+constexpr inline auto count_digits_base(uint64_t n) -> int {
+    if constexpr (t_format_type == FormatType::b) {
+        int result = 0;
+
+        while (n) {
+            n = n >> 1;
+            result += 1;
+        }
+
+        return result;
+    } else {
+        if constexpr (t_format_type == FormatType::x) {
+            int result = 0;
+
+            while (n) {
+                n = n >> 4;
+                result += 1;
+            }
+
+            return (result + count_digits_base<FormatType::b>(n));
+        } else {
+            if (!std::is_constant_evaluated()) {
+                return do_count_digits_decimal(n);
+            }
+            return count_digits_decimal_fallback(n);
+        }
     }
-    return count_digits_fallback(n);
 }
 
 
-// Converts value in the range [0, 100) to a string.
-constexpr inline const char* digits2(size_t value) {
+// Converts value in the range [0, base^2) to a string.
+template <FormatType t_format_type>
+constexpr inline const char* digits2_base(size_t value) {
     // GCC generates slightly better code when value is pointer-size.
-    return &"0001020304050607080910111213141516171819"
-            "2021222324252627282930313233343536373839"
-            "4041424344454647484950515253545556575859"
-            "6061626364656667686970717273747576777879"
-            "8081828384858687888990919293949596979899"[value * 2];
+    if constexpr (t_format_type == FormatType::b) {
+        return &"00011011"[value * 2];
+    } else {
+        if constexpr (t_format_type == FormatType::x) {
+            // clang-format off
+            return &"000102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F"
+                    "202122232425262728292A2B2C2D2E2F303132333435363738393A3B3C3D3E3F"
+                    "404142434445464748494A4B4C4D4E4F505152535455565758595A5B5C5D5E5F"
+                    "606162636465666768696A6B6C6D6E6F707172737475767778797A7B7C7D7E7F"
+                    "808182838485868788898A8B8C8D8E8F909192939495969798999A9B9C9D9E9F"
+                    "A0A1A2A3A4A5A6A7A8A9AAABACADAEAFB0B1B2B3B4B5B6B7B8B9BABBBCBDBEBF"
+                    "C0C1C2C3C4C5C6C7C8C9CACBCCCDCECFD0D1D2D3D4D5D6D7D8D9DADBDCDDDEDF"
+                    "E0E1E2E3E4E5E6E7E8E9EAEBECEDEEEFF0F1F2F3F4F5F6F7F8F9FAFBFCFDFEFF"[value * 2];
+            // clang-format on
+        } else {
+            return &"0001020304050607080910111213141516171819"
+                    "2021222324252627282930313233343536373839"
+                    "4041424344454647484950515253545556575859"
+                    "6061626364656667686970717273747576777879"
+                    "8081828384858687888990919293949596979899"[value * 2];
+        }
+    }
 }
 
 
@@ -86,24 +126,66 @@ constexpr inline void copy2(char* dst, const char* src) {
     *dst   = static_cast<char>(*src);
 }
 
-template <typename uint_t>
-constexpr inline void format_decimal(char* out, uint_t value, int size) {
-    if (count_digits(value) > size) return;
+template <FormatType t_format_type>
+consteval inline unsigned get_base_divisor() {
+    switch (t_format_type) {
+    case FormatType::b:
+        return 2;
+    case FormatType::x:
+        return 16;
+    default:
+        return 10;
+    }
+}
 
-    out += size;
-    while (value >= 100) {
-        out -= 2;
-        copy2(out, digits2(static_cast<size_t>(value % 100)));
-        value /= 100;
+template <FormatType t_format_type, typename uint_t>
+constexpr inline void format_base(char* out, uint_t value, int n_digits,
+                                  int size) {
+    constexpr unsigned divisor        = get_base_divisor<t_format_type>();
+    constexpr unsigned square_divisor = const_pow(divisor, 2);
+
+    if (n_digits > size) {
+        for (int i = 0; i < size; ++i) {
+            *(out++) = 'f';
+        }
+        return;
     }
 
-    if (value < 10) {
-        *--out = static_cast<char>('0' + value);
+    out += size;
+    while (value >= square_divisor) {
+        out -= 2;
+        copy2(out, digits2_base<t_format_type>(
+                       static_cast<size_t>(value % square_divisor)));
+        value /= square_divisor;
+    }
+
+    if (value < divisor) {
+        *--out = digits2_base<t_format_type>(value*divisor)[0];
         return;
     }
 
     out -= 2;
-    copy2(out, digits2(static_cast<size_t>(value)));
+    copy2(out, digits2_base<t_format_type>(static_cast<size_t>(value)));
+}
+
+
+// returns {abs_value, was_negative}
+template <std::signed_integral int_t>
+constexpr std::pair<typename std::make_unsigned<int_t>::type, bool>
+get_abs_value(int_t value) {
+    using uint_t = typename std::make_unsigned<int_t>::type;
+
+    uint_t abs_value = static_cast<uint_t>(value);
+
+    const bool negative = value < 0;
+    if (negative) abs_value = 0 - abs_value;
+
+    return {abs_value, negative};
+}
+
+template <std::unsigned_integral int_t>
+constexpr std::pair<int_t, bool> get_abs_value(int_t value) {
+    return {value, false};
 }
 
 
@@ -114,21 +196,29 @@ constexpr inline void format_decimal(char* out, uint_t value, int size) {
  */
 
 
-template <std::unsigned_integral uint_t>
-constexpr inline void format_int(char* out, uint_t value, fmt_data_t fmt_node) {
-    format_decimal(out, value, fmt_node.length);
+template <fmt_data_t t_fmt_node, std::unsigned_integral uint_t>
+constexpr inline void format_int(char* out, uint_t value) {
+    format_base<t_fmt_node.type>(out, value,
+                                 count_digits_base<t_fmt_node.type>(value),
+                                 t_fmt_node.length);
 }
 
-template <std::signed_integral uint_t>
-constexpr inline void format_int(char* out, uint_t value, fmt_data_t fmt_node) {
-    auto       abs_value = static_cast<uint64_t>(value);
-    const bool negative  = value < 0;
 
-    if (negative) abs_value = 0 - abs_value;
-    format_decimal(out + 1 * (negative), abs_value,
-                   fmt_node.length - 1 * (negative));
+template <fmt_data_t t_fmt_node, std::signed_integral int_t>
+constexpr inline void format_int(char* out, int_t value) {
+    const auto [abs_value, negative] = get_abs_value(value);
 
-    if (negative) *out = '-';
+    const std::size_t n_digits = count_digits_base<t_fmt_node.type>(abs_value);
+
+    format_base<t_fmt_node.type>(out + 1 * (negative), abs_value, n_digits,
+                                 t_fmt_node.length - 1 * (negative));
+
+    if constexpr (t_fmt_node.has_zero_padding) {
+        if (negative) *(out) = '-';
+    } else {
+        if (n_digits < t_fmt_node.length)
+            if (negative) *(out + t_fmt_node.length - n_digits - 1) = '-';
+    }
 }
 
 
@@ -139,12 +229,38 @@ constexpr inline void format_int(char* out, uint_t value, fmt_data_t fmt_node) {
  */
 
 
-template <std::floating_point float_t>
-constexpr inline void format_float(char* out, float_t value,
-                                   fmt_data_t fmt_data) {
+template <fmt_data_t t_fmt_node, std::floating_point float_t>
+constexpr inline void format_float(char* out, float_t value) {
+    // clang-format off
+    constexpr fmt_data_t fmt_node_integral = {
+        t_fmt_node.has_zero_padding,                  // has_zero_padding
+        t_fmt_node.length - t_fmt_node.precision - 1, // length
+        t_fmt_node.precision,                         // ignored
+        FormatType::d,                                // type
+        t_fmt_node.position                           // ignored
+    };
+    constexpr fmt_data_t fmt_node_fractional = {
+        true,                                         // has_zero_padding
+        t_fmt_node.precision,                         // length
+        t_fmt_node.precision,                         // ignored
+        FormatType::d,                                // type
+        t_fmt_node.position                           // ignored
+    };
+    // clang-format on
 
-    *(out)                                            = 'f';
-    *(out + fmt_data.length - fmt_data.precision - 1) = '.';
+    *(out + t_fmt_node.length - t_fmt_node.precision - 1) = '.';
+
+    const int integral = static_cast<int>(value);
+
+    constexpr std::size_t factor = const_pow(10, t_fmt_node.precision);
+    const int fractional = static_cast<int>((value - integral) * factor);
+
+    const auto [fractional_abs, fractional_negative] =
+        get_abs_value(fractional);
+
+    format_int<fmt_node_integral, int>(out, integral);
+    format_int<fmt_node_fractional, uint16_t>(
+        out + t_fmt_node.length - t_fmt_node.precision, fractional_abs);
 }
 
 

examples/src/examples.cpp

@@ -5,7 +5,7 @@
 using namespace const_fmt;
 
 int main() {
-    constexpr auto s = "abcdef {:04}"_const_fmt(123);
+    constexpr auto s = "This is an integer: {:08x}, and this is a float: {:09.4b}"_const_fmt(122u, -86.2);
 
     // Convert s (with a type of 'std::array<char, N>') into something
     // writable to std::cout

test/CMakeLists.txt

@@ -25,5 +25,8 @@ endmacro()
 
 package_add_test(utility_test src/utility.cpp)
 package_add_test(parse_test src/parse.cpp)
-package_add_test(format_test src/format.cpp)
+package_add_test(format_utility_test src/format_utility.cpp)
+package_add_test(format_decimal_test src/format_decimal.cpp)
+package_add_test(format_binary_test src/format_binary.cpp)
+package_add_test(format_hex_test src/format_hex.cpp)
 

test/src/format_binary.cpp

@@ -0,0 +1,59 @@
+#include <const_fmt/format.h>
+#include <gtest/gtest.h>
+
+
+using namespace const_fmt;
+using namespace const_fmt::const_fmt_detail;
+
+
+TEST(FormatBinary, positive_int) {
+    constexpr std::array<char, 8> control1   = {'0', '0', '0', '0',
+                                              '0', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08b}">(0b10);
+
+    constexpr std::array<char, 8> control2   = {' ', ' ', '1', '0',
+                                              '1', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8b}">(0b101010);
+
+    constexpr std::array<char, 8> control3   = {'0', '0', '0', '1',
+                                              '1', '0', '0', '1'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4b}">(0b11001);
+
+    constexpr std::array<char, 4> control4   = {'1', '0', '1', '1'};
+    constexpr std::array<char, 4> formatted4 = const_format<"{:4b}">(0b1011);
+
+    constexpr std::array<char, 4> control5   = {'f', 'f', 'f', 'f'};
+    constexpr std::array<char, 4> formatted5 = const_format<"{:4b}">(0b10011);
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+    EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
+}
+
+TEST(FormatBinary, negative_int) {
+    constexpr std::array<char, 8> control1   = {'-', '0', '0', '0',
+                                              '0', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08b}">(-0b10);
+
+    constexpr std::array<char, 8> control2   = {' ', '-', '1', '0',
+                                                '1', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8b}">(-0b101010);
+
+    constexpr std::array<char, 8> control3   = {'-', '0', '0', '1',
+                                              '0', '0', '1', '1'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4b}">(-0b10011);
+
+    constexpr std::array<char, 5> control4   = {'-', '1', '1', '0', '1'};
+    constexpr std::array<char, 5> formatted4 = const_format<"{:5b}">(-0b1101);
+
+    constexpr std::array<char, 5> control5   = {'-', 'f', 'f', 'f', 'f'};
+    constexpr std::array<char, 5> formatted5 = const_format<"{:05b}">(-0b10101);
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+    EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
+}

test/src/format_decimal.cpp

@@ -0,0 +1,103 @@
+#include <const_fmt/format.h>
+#include <gtest/gtest.h>
+
+
+using namespace const_fmt;
+using namespace const_fmt::const_fmt_detail;
+
+
+TEST(FormatDecimal, positive_int) {
+    constexpr std::array<char, 8> control1   = {'0', '0', '0', '0',
+                                              '0', '0', '0', '2'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08}">(2);
+
+    constexpr std::array<char, 8> control2   = {' ', ' ', ' ', '2',
+                                              '2', '2', '2', '2'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8}">(22222);
+
+    constexpr std::array<char, 8> control3   = {'0', '0', '0', '1',
+                                              '2', '3', '4', '5'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4}">(12345);
+
+    constexpr std::array<char, 4> control4   = {'6', '7', '8', '9'};
+    constexpr std::array<char, 4> formatted4 = const_format<"{:4}">(6789);
+
+    constexpr std::array<char, 4> control5   = {'f', 'f', 'f', 'f'};
+    constexpr std::array<char, 4> formatted5 = const_format<"{:4}">(67895);
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+    EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
+}
+
+TEST(FormatDecimal, negative_int) {
+    constexpr std::array<char, 8> control1   = {'-', '0', '0', '0',
+                                              '0', '0', '0', '2'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08}">(-2);
+
+    constexpr std::array<char, 8> control2   = {' ', ' ', '-', '2',
+                                              '2', '2', '2', '2'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8}">(-22222);
+
+    constexpr std::array<char, 8> control3   = {'-', '0', '0', '1',
+                                              '2', '3', '4', '5'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4}">(-12345);
+
+    constexpr std::array<char, 5> control4   = {'-', '6', '7', '8', '9'};
+    constexpr std::array<char, 5> formatted4 = const_format<"{:5}">(-6789);
+
+    constexpr std::array<char, 5> control5   = {'-', 'f', 'f', 'f', 'f'};
+    constexpr std::array<char, 5> formatted5 = const_format<"{:05}">(-66789);
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+    EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
+}
+
+TEST(FormatDecimal, positive_float) {
+    constexpr std::array<char, 8> control1   = {'0', '0', '2', '.',
+                                              '3', '4', '5', '6'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08.4}">(2.3456);
+
+    // Float error: 2323.2 -> 2323.1
+    constexpr std::array<char, 8> control2   = {' ', ' ', '2', '3',
+                                              '2', '3', '.', '1'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8.1}">(2323.2);
+
+    constexpr std::array<char, 8> control3   = {'1', '2', '3', '4',
+                                              '.', '5', '0', '0'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.3}">(1234.5);
+
+    // Float error: .9 -> .8
+    constexpr std::array<char, 4> control4   = {'f', 'f', '.', '8'};
+    constexpr std::array<char, 4> formatted4 = const_format<"{:4.1}">(678.9);
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+    EXPECT_EQ(control4, formatted4);
+}
+
+TEST(FormatDecimal, negative_float) {
+    constexpr std::array<char, 8> control1   = {'-', '0', '2', '.',
+                                                '3', '4', '5', '6'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08.4}">(-2.3456);
+
+    // Float error: 2323.2 -> 2323.1
+    constexpr std::array<char, 8> control2   = {' ', '-', '2', '3',
+                                                '2', '3', '.', '1'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8.1}">(-2323.2);
+
+    constexpr std::array<char, 8> control3   = {'-', 'f', 'f', 'f',
+                                                '.', '5', '0', '0'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.3}">(-1234.5);
+
+
+    EXPECT_EQ(control1, formatted1);
+    EXPECT_EQ(control2, formatted2);
+    EXPECT_EQ(control3, formatted3);
+}

test/src/format_hex.cpp

@@ -6,61 +6,54 @@ using namespace const_fmt;
 using namespace const_fmt::const_fmt_detail;
 
 
-TEST(Format, positive_int) {
+TEST(FormatHex, positive_int) {
     constexpr std::array<char, 8> control1   = {'0', '0', '0', '0',
-                                                '0', '0', '0', '2'};
-    constexpr std::array<char, 8> formatted1 = const_format<"{:08}">(2);
+                                                '0', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08x}">(0x10);
 
-    constexpr std::array<char, 8> control2   = {' ', ' ', ' ', '2',
-                                                '2', '2', '2', '2'};
-    constexpr std::array<char, 8> formatted2 = const_format<"{:8}">(22222);
+    constexpr std::array<char, 8> control2   = {' ', ' ', ' ', 'F',
+                                                'F', 'A', '7', '6'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8x}">(0xffa76);
 
-    constexpr std::array<char, 8> control3   = {'0', '0', '0', '1',
-                                                '2', '3', '4', '5'};
-    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4}">(12345);
+    constexpr std::array<char, 8> control3   = {'0', '0', '0', '0',
+                                                'B', 'C', 'E', 'F'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4x}">(0xbcef);
 
-    constexpr std::array<char, 4> control4   = {'6', '7', '8', '9'};
-    constexpr std::array<char, 4> formatted4 = const_format<"{:4}">(6789);
+    constexpr std::array<char, 4> control4   = {'A', 'D', '0', '1'};
+    constexpr std::array<char, 4> formatted4 = const_format<"{:4x}">(0xad01);
+
+    constexpr std::array<char, 4> control5   = {'f', 'f', 'f', 'f'};
+    constexpr std::array<char, 4> formatted5 = const_format<"{:4x}">(0x12345);
 
     EXPECT_EQ(control1, formatted1);
     EXPECT_EQ(control2, formatted2);
     EXPECT_EQ(control3, formatted3);
     EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
 }
 
-TEST(Format, negative_int) {
+TEST(FormatHex, negative_int) {
     constexpr std::array<char, 8> control1   = {'-', '0', '0', '0',
-                                                '0', '0', '0', '2'};
-    constexpr std::array<char, 8> formatted1 = const_format<"{:08}">(-2);
+                                                '0', '0', '1', '0'};
+    constexpr std::array<char, 8> formatted1 = const_format<"{:08x}">(-0x10);
 
-    constexpr std::array<char, 8> control2   = {' ', ' ', '-', '2',
-                                                '2', '2', '2', '2'};
-    constexpr std::array<char, 8> formatted2 = const_format<"{:8}">(-22222);
+    constexpr std::array<char, 8> control2   = {' ', ' ', '-', 'F',
+                                                'F', 'A', '7', '6'};
+    constexpr std::array<char, 8> formatted2 = const_format<"{:8x}">(-0xffa76);
 
-    constexpr std::array<char, 8> control3   = {'-', '0', '0', '1',
-                                                '2', '3', '4', '5'};
-    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4}">(-12345);
+    constexpr std::array<char, 8> control3   = {'-', '0', '0', '0',
+                                                'B', 'C', 'E', 'F'};
+    constexpr std::array<char, 8> formatted3 = const_format<"{:08.4x}">(-0xbcef);
 
-    constexpr std::array<char, 5> control4   = {'-', '6', '7', '8', '9'};
-    constexpr std::array<char, 5> formatted4 = const_format<"{:5}">(-6789);
+    constexpr std::array<char, 4> control4   = {'-', 'A', 'D', '1'};
+    constexpr std::array<char, 4> formatted4 = const_format<"{:4x}">(-0xad1);
+
+    constexpr std::array<char, 4> control5   = {'-', 'f', 'f', 'f'};
+    constexpr std::array<char, 4> formatted5 = const_format<"{:04x}">(-0x1234);
 
     EXPECT_EQ(control1, formatted1);
     EXPECT_EQ(control2, formatted2);
     EXPECT_EQ(control3, formatted3);
     EXPECT_EQ(control4, formatted4);
+    EXPECT_EQ(control5, formatted5);
 }
-//
-//TEST(Format, positive_float) {
-//    // TODO
-//    EXPECT_EQ(true, false);
-//}
-//
-//TEST(Format, negative_float) {
-//    // TODO
-//    EXPECT_EQ(true, false);
-//}
-//
-//TEST(Format, string) {
-//    // TODO
-//    EXPECT_EQ(true, false);
-//}

test/src/format_utility.cpp

@@ -0,0 +1,44 @@
+#include <const_fmt/format_impl.h>
+#include <limits>
+#include <gtest/gtest.h>
+
+
+using namespace const_fmt;
+using namespace const_fmt::const_fmt_detail;
+
+
+TEST(FormatUtility, count_digits_base_decimal) {
+    constexpr unsigned length1 = count_digits_base<FormatType::d>(123);
+    constexpr unsigned length2 = count_digits_base<FormatType::d>(std::numeric_limits<uint64_t>::max());
+    constexpr unsigned length3 = count_digits_base<FormatType::d>(10000011);
+    constexpr unsigned length4 = count_digits_base<FormatType::d>(1);
+
+    EXPECT_EQ(length1, 3);
+    EXPECT_EQ(length2, 20);
+    EXPECT_EQ(length3, 8);
+    EXPECT_EQ(length4, 1);
+}
+
+TEST(FormatUtility, count_digits_base_binary) {
+    constexpr unsigned length1 = count_digits_base<FormatType::b>(0b1001);
+    constexpr unsigned length2 = count_digits_base<FormatType::b>(std::numeric_limits<uint64_t>::max());
+    constexpr unsigned length3 = count_digits_base<FormatType::b>(0b10000001);
+    constexpr unsigned length4 = count_digits_base<FormatType::b>(0b01);
+
+    EXPECT_EQ(length1, 4);
+    EXPECT_EQ(length2, 64);
+    EXPECT_EQ(length3, 8);
+    EXPECT_EQ(length4, 1);
+}
+
+TEST(FormatUtility, count_digits_base_hex) {
+    constexpr unsigned length1 = count_digits_base<FormatType::x>(0x123);
+    constexpr unsigned length2 = count_digits_base<FormatType::x>(std::numeric_limits<uint64_t>::max());
+    constexpr unsigned length3 = count_digits_base<FormatType::x>(0x1000000f);
+    constexpr unsigned length4 = count_digits_base<FormatType::x>(0x01);
+
+    EXPECT_EQ(length1, 3);
+    EXPECT_EQ(length2, 16);
+    EXPECT_EQ(length3, 8);
+    EXPECT_EQ(length4, 1);
+}