[libc++][test] Fix MSVC warnings C6054, C6001, C4242

[fsb4000]

Summary

warning C4242: '=': conversion from 'int' to 'char', possible loss of data
and double to long double.

Also

llvm-project\libcxx\test\std\utilities\format\format.functions\format_tests.h(121) : warning C6054: String 'begin' might not be zero-terminated.: Lines: 88, 89, 90, 91, 92, 109, 110, 121

llvm-project\libcxx\test\std\utilities\format\format.functions\format_tests.h(121) : warning C6001: Using uninitialized memory 'begin'.: Lines: 88, 89, 90, 91, 92, 109, 110, 121

llvm-project\libcxx\test\std\utilities\format\format.functions\format_tests.h(125) : warning C6001: Using uninitialized memory 'end'.: Lines: 88, 89, 90, 91, 92, 125

and -NaN is formatted like "-nan(ind)"

Also I found something else.
Currently this test fails on MSVC with

Format string   answer is '{:#g}'
Expected output answer is '0.'
Actual output   answer is '0.00000'

This is tested there: https://github.com/llvm/llvm-project/blob/486a3c4662cb052329b96537da18893d73138b64/libcxx/test/std/utilities/format/format.functions/format_tests.h#L2035

I don't know what standard says about it but libfmt agrees with MSVC: https://gcc.godbolt.org/z/vd38r5W9x

[Mordante]

Also I found something else.
Currently this test fails on MSVC with

Format string   answer is '{:#g}'
Expected output answer is '0.'
Actual output   answer is '0.00000'

This seems like a bug, looking at http://eel.is/c++draft/format#string.std-6 the trailing zeros should remain. It seems I missed that. Good catch.

For now I put this on request changes to remove it from the review queue, so we can discuss what to do about the NaNs.

libcxx/test/std/utilities/format/format.functions/format_tests.h

1031

MSVC STL is wrong per
http://eel.is/c++draft/format#string.std-22

I added code to not directly use the result of std::to_chars since I know it can give the "wrong" results.
https://github.com/llvm/llvm-project/blob/main/libcxx/include/__format/formatter_floating_point.h#L582

But let's discuss this further on MSVC STL's Discord.

[fsb4000]

now MSVC STL formats -NaN correctly: https://github.com/microsoft/STL/pull/3001
Thanks @Mordante !

[Mordante]

LGTM, thanks! Please update the commit message before committing by removing the -NaN and the '{:#g}' issue parts.
(I am busy resolving the #g bug in libc++.)

[fsb4000]

Thanks.

I pushed https://github.com/llvm/llvm-project/commit/6bb51bf06214af3690af7034f4edeb265732c481

libcxx/test/std/utilities/format/format.functions/format_tests.h

if (begin != end && *begin != CharT('}'))
       throw_format_error("The format-spec should consume the input or end with a '}'");
 
     return begin;
   }
 
   template <class Out>
   auto format(status s, basic_format_context<Out, CharT>& ctx) -> decltype(ctx.out()) {
     const char* names[] = {"foo", "bar", "foobar"};
-    char buffer[6];
-    const char* begin;
-    const char* end;
+    char buffer[7];
+    const char* begin = names[0];
+    const char* end = names[0];
     switch (type) {
     case 0:
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'x';
       end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
+      buffer[6] = '\0';
       break;
 
     case 1:
       begin = buffer;
       buffer[0] = '0';
       buffer[1] = 'X';
       end = std::to_chars(&buffer[2], std::end(buffer), static_cast<uint16_t>(s), 16).ptr;
-      std::transform(static_cast<const char*>(&buffer[2]), end, &buffer[2], [](char c) { return std::toupper(c); });
+      std::transform(static_cast<const char*>(&buffer[2]), end, &buffer[2], [](char c) {
+        return static_cast<char>(std::toupper(c)); });
+      buffer[6] = '\0';
       break;
 
     case 2:
       switch (s) {
       case status::foo:
         begin = names[0];
         break;
       case status::bar:
void format_test_char_as_integer(TestFunction check, ExceptionTest check_exception) {
 
   // *** type ***
   for (const auto& fmt : invalid_types<CharT>("bBcdoxX"))
     check_exception("The format-spec type has a type not supported for a char argument", fmt, '*');
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_hex_lower_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // Test whether the hexadecimal letters are the proper case.
   // The precision is too large for float, so two tests are used.
   check.template operator()<"answer is '{:a}'">(SV("answer is '1.abcp+0'"), F(0x1.abcp+0));
   check.template operator()<"answer is '{:a}'">(SV("answer is '1.defp+0'"), F(0x1.defp+0));
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7a}'">(SV("answer is '   1p-2'"), F(0.25));
void format_test_floating_point_hex_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:^>6a}'">(SV("answer is '^^^nan'"), nan_pos);
   check.template operator()<"answer is '{:^<6a}'">(SV("answer is 'nan^^^'"), nan_pos);
   check.template operator()<"answer is '{:^^6a}'">(SV("answer is '^nan^^'"), nan_pos);
 
   check.template operator()<"answer is '{:0>7a}'">(SV("answer is '000-nan'"), nan_neg);
   check.template operator()<"answer is '{:0<7a}'">(SV("answer is '-nan000'"), nan_neg);
   check.template operator()<"answer is '{:0^7a}'">(SV("answer is '0-nan00'"), nan_neg);
 
   // Test whether zero padding is ignored
   check.template operator()<"answer is '{:>07a}'">(SV("answer is '   1p-2'"), F(0.25));
   check.template operator()<"answer is '{:<07a}'">(SV("answer is '1p-2   '"), F(0.25));
   check.template operator()<"answer is '{:^07a}'">(SV("answer is ' 1p-2  '"), F(0.25));
 
   // *** Sign ***
   check.template operator()<"answer is '{:a}'">(SV("answer is '0p+0'"), F(0));
   check.template operator()<"answer is '{:-a}'">(SV("answer is '0p+0'"), F(0));
   check.template operator()<"answer is '{:+a}'">(SV("answer is '+0p+0'"), F(0));
void format_test_floating_point_hex_lower_case(TestFunction check) {
   // See format_test_floating_point_hex_lower_case_precision
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_hex_upper_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // Test whether the hexadecimal letters are the proper case.
   // The precision is too large for float, so two tests are used.
   check.template operator()<"answer is '{:A}'">(SV("answer is '1.ABCP+0'"), F(0x1.abcp+0));
   check.template operator()<"answer is '{:A}'">(SV("answer is '1.DEFP+0'"), F(0x1.defp+0));
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7A}'">(SV("answer is '   1P-2'"), F(0.25));
void format_test_floating_point_hex_upper_case(TestFunction check) {
   // See format_test_floating_point_hex_upper_case_precision
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_hex_lower_case_precision(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:14.6a}'">(SV("answer is '   1.000000p-2'"), F(0.25));
   check.template operator()<"answer is '{:>14.6a}'">(SV("answer is '   1.000000p-2'"), F(0.25));
   check.template operator()<"answer is '{:<14.6a}'">(SV("answer is '1.000000p-2   '"), F(0.25));
   check.template operator()<"answer is '{:^14.6a}'">(SV("answer is ' 1.000000p-2  '"), F(0.25));
 
   check.template operator()<"answer is '{:->14.6a}'">(SV("answer is '---1.000000p-3'"), F(125e-3));
void format_test_floating_point_hex_lower_case_precision(TestFunction check) {
   check.template operator()<"answer is '{: 010.6a}'">(SV("answer is '      -nan'"), nan_neg);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_hex_upper_case_precision(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:14.6A}'">(SV("answer is '   1.000000P-2'"), F(0.25));
   check.template operator()<"answer is '{:>14.6A}'">(SV("answer is '   1.000000P-2'"), F(0.25));
   check.template operator()<"answer is '{:<14.6A}'">(SV("answer is '1.000000P-2   '"), F(0.25));
   check.template operator()<"answer is '{:^14.6A}'">(SV("answer is ' 1.000000P-2  '"), F(0.25));
 
   check.template operator()<"answer is '{:->14.6A}'">(SV("answer is '---1.000000P-3'"), F(125e-3));
void format_test_floating_point_hex_upper_case_precision(TestFunction check) {
   check.template operator()<"answer is '{: 010.6A}'">(SV("answer is '      -NAN'"), nan_neg);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_scientific_lower_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:15e}'">(SV("answer is '   2.500000e-01'"), F(0.25));
   check.template operator()<"answer is '{:>15e}'">(SV("answer is '   2.500000e-01'"), F(0.25));
   check.template operator()<"answer is '{:<15e}'">(SV("answer is '2.500000e-01   '"), F(0.25));
   check.template operator()<"answer is '{:^15e}'">(SV("answer is ' 2.500000e-01  '"), F(0.25));
 
   check.template operator()<"answer is '{:->15e}'">(SV("answer is '---1.250000e-01'"), F(125e-3));
void format_test_floating_point_scientific_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:.10e}'">(SV("answer is '3.1250000000e-02'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_scientific_upper_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:15E}'">(SV("answer is '   2.500000E-01'"), F(0.25));
   check.template operator()<"answer is '{:>15E}'">(SV("answer is '   2.500000E-01'"), F(0.25));
   check.template operator()<"answer is '{:<15E}'">(SV("answer is '2.500000E-01   '"), F(0.25));
   check.template operator()<"answer is '{:^15E}'">(SV("answer is ' 2.500000E-01  '"), F(0.25));
 
   check.template operator()<"answer is '{:->15E}'">(SV("answer is '---1.250000E-01'"), F(125e-3));
void format_test_floating_point_scientific_upper_case(TestFunction check) {
   check.template operator()<"answer is '{:.10E}'">(SV("answer is '3.1250000000E-02'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_fixed_lower_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:11f}'">(SV("answer is '   0.250000'"), F(0.25));
   check.template operator()<"answer is '{:>11f}'">(SV("answer is '   0.250000'"), F(0.25));
   check.template operator()<"answer is '{:<11f}'">(SV("answer is '0.250000   '"), F(0.25));
   check.template operator()<"answer is '{:^11f}'">(SV("answer is ' 0.250000  '"), F(0.25));
 
   check.template operator()<"answer is '{:->11f}'">(SV("answer is '---0.125000'"), F(125e-3));
void format_test_floating_point_fixed_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:.10f}'">(SV("answer is '0.0312500000'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_fixed_upper_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:11F}'">(SV("answer is '   0.250000'"), F(0.25));
   check.template operator()<"answer is '{:>11F}'">(SV("answer is '   0.250000'"), F(0.25));
   check.template operator()<"answer is '{:<11F}'">(SV("answer is '0.250000   '"), F(0.25));
   check.template operator()<"answer is '{:^11F}'">(SV("answer is ' 0.250000  '"), F(0.25));
 
   check.template operator()<"answer is '{:->11F}'">(SV("answer is '---0.125000'"), F(125e-3));
void format_test_floating_point_fixed_upper_case(TestFunction check) {
   check.template operator()<"answer is '{:.10F}'">(SV("answer is '0.0312500000'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_general_lower_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7g}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:>7g}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:<7g}'">(SV("answer is '0.25   '"), F(0.25));
   check.template operator()<"answer is '{:^7g}'">(SV("answer is ' 0.25  '"), F(0.25));
 
   check.template operator()<"answer is '{:->8g}'">(SV("answer is '---0.125'"), F(125e-3));
void format_test_floating_point_general_lower_case(TestFunction check) {
   check.template operator()<"answer is '{:.10g}'">(SV("answer is '0.03125'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_general_upper_case(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7G}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:>7G}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:<7G}'">(SV("answer is '0.25   '"), F(0.25));
   check.template operator()<"answer is '{:^7G}'">(SV("answer is ' 0.25  '"), F(0.25));
 
   check.template operator()<"answer is '{:->8G}'">(SV("answer is '---0.125'"), F(125e-3));
void format_test_floating_point_general_upper_case(TestFunction check) {
   check.template operator()<"answer is '{:.10G}'">(SV("answer is '0.03125'"), 0.03125);
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_default(TestFunction check) {
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:>7}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:<7}'">(SV("answer is '0.25   '"), F(0.25));
   check.template operator()<"answer is '{:^7}'">(SV("answer is ' 0.25  '"), F(0.25));
 
   check.template operator()<"answer is '{:->8}'">(SV("answer is '---0.125'"), F(125e-3));
void format_test_floating_point_default(TestFunction check) {
 
   // *** locale-specific form ***
   // See locale-specific_form.pass.cpp
 }
 
 template <class F, class CharT, class TestFunction>
 void format_test_floating_point_default_precision(TestFunction check) {
 
-  auto nan_pos = std::numeric_limits<F>::quiet_NaN(); // "nan"
-  auto nan_neg = std::copysign(nan_pos, -1.0);        // "-nan"
+  auto nan_pos = std::numeric_limits<F>::quiet_NaN();                          // "nan"
+  auto nan_neg = std::copysign(nan_pos, static_cast<decltype(nan_pos)>(-1.0)); // "-nan"
 
   // *** align-fill & width ***
   check.template operator()<"answer is '{:7.6}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:>7.6}'">(SV("answer is '   0.25'"), F(0.25));
   check.template operator()<"answer is '{:<7.6}'">(SV("answer is '0.25   '"), F(0.25));
   check.template operator()<"answer is '{:^7.6}'">(SV("answer is ' 0.25  '"), F(0.25));
 
   check.template operator()<"answer is '{:->8.6}'">(SV("answer is '---0.125'"), F(125e-3));