| //===----------------------------------------------------------------------===// |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H |
| #define TEST_STD_UTILITIES_FORMAT_FORMAT_FUNCTIONS_FORMAT_TESTS_H |
| |
| #include "make_string.h" |
| |
| // In this file the following template types are used: |
| // TestFunction must be callable as check(expected-result, string-to-format, args-to-format...) |
| // ExceptionTest must be callable as check_exception(expected-exception, string-to-format, args-to-format...) |
| |
| #define STR(S) MAKE_STRING(CharT, S) |
| #define CSTR(S) MAKE_CSTRING(CharT, S) |
| |
| template <class CharT> |
| std::vector<std::basic_string<CharT>> invalid_types(std::string valid) { |
| std::vector<std::basic_string<CharT>> result; |
| |
| #define CASE(T) \ |
| case #T[0]: \ |
| result.push_back(STR("Invalid formatter type {:" #T "}")); \ |
| break; |
| |
| for (auto type : "aAbBcdeEfFgGopsxX") { |
| if (valid.find(type) != std::string::npos) |
| continue; |
| |
| switch (type) { |
| CASE(a) |
| CASE(A) |
| CASE(b) |
| CASE(B) |
| CASE(c) |
| CASE(d) |
| CASE(e) |
| CASE(E) |
| CASE(f) |
| CASE(F) |
| CASE(g) |
| CASE(G) |
| CASE(o) |
| CASE(p) |
| CASE(s) |
| CASE(x) |
| CASE(X) |
| case 0: |
| break; |
| default: |
| assert(false && "Add the type to the list of cases."); |
| } |
| } |
| #undef CASE |
| |
| return result; |
| } |
| |
| template <class CharT, class T, class TestFunction, class ExceptionTest> |
| void format_test_string(T world, T universe, TestFunction check, |
| ExceptionTest check_exception) { |
| |
| // *** Valid input tests *** |
| // Unsed argument is ignored. TODO FMT what does the Standard mandate? |
| check(STR("hello world"), STR("hello {}"), world, universe); |
| check(STR("hello world and universe"), STR("hello {} and {}"), world, |
| universe); |
| check(STR("hello world"), STR("hello {0}"), world, universe); |
| check(STR("hello universe"), STR("hello {1}"), world, universe); |
| check(STR("hello universe and world"), STR("hello {1} and {0}"), world, |
| universe); |
| |
| check(STR("hello world"), STR("hello {:_>}"), world); |
| check(STR("hello world"), STR("hello {:>8}"), world); |
| check(STR("hello ___world"), STR("hello {:_>8}"), world); |
| check(STR("hello _world__"), STR("hello {:_^8}"), world); |
| check(STR("hello world___"), STR("hello {:_<8}"), world); |
| |
| check(STR("hello >>>world"), STR("hello {:>>8}"), world); |
| check(STR("hello <<<world"), STR("hello {:<>8}"), world); |
| check(STR("hello ^^^world"), STR("hello {:^>8}"), world); |
| |
| check(STR("hello $world"), STR("hello {:$>{}}"), world, 6); |
| check(STR("hello $world"), STR("hello {0:$>{1}}"), world, 6); |
| check(STR("hello $world"), STR("hello {1:$>{0}}"), 6, world); |
| |
| check(STR("hello world"), STR("hello {:.5}"), world); |
| check(STR("hello unive"), STR("hello {:.5}"), universe); |
| |
| check(STR("hello univer"), STR("hello {:.{}}"), universe, 6); |
| check(STR("hello univer"), STR("hello {0:.{1}}"), universe, 6); |
| check(STR("hello univer"), STR("hello {1:.{0}}"), 6, universe); |
| |
| check(STR("hello %world%"), STR("hello {:%^7.7}"), world); |
| check(STR("hello univers"), STR("hello {:%^7.7}"), universe); |
| check(STR("hello %world%"), STR("hello {:%^{}.{}}"), world, 7, 7); |
| check(STR("hello %world%"), STR("hello {0:%^{1}.{2}}"), world, 7, 7); |
| check(STR("hello %world%"), STR("hello {0:%^{2}.{1}}"), world, 7, 7); |
| check(STR("hello %world%"), STR("hello {1:%^{0}.{2}}"), 7, world, 7); |
| |
| check(STR("hello world"), STR("hello {:_>s}"), world); |
| check(STR("hello $world"), STR("hello {:$>{}s}"), world, 6); |
| check(STR("hello world"), STR("hello {:.5s}"), world); |
| check(STR("hello univer"), STR("hello {:.{}s}"), universe, 6); |
| check(STR("hello %world%"), STR("hello {:%^7.7s}"), world); |
| |
| check(STR("hello #####uni"), STR("hello {:#>8.3s}"), universe); |
| check(STR("hello ##uni###"), STR("hello {:#^8.3s}"), universe); |
| check(STR("hello uni#####"), STR("hello {:#<8.3s}"), universe); |
| |
| // *** sign *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("hello {:-}"), world); |
| |
| // *** alternate form *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("hello {:#}"), world); |
| |
| // *** zero-padding *** |
| check_exception("A format-spec width field shouldn't have a leading zero", |
| STR("hello {:0}"), world); |
| |
| // *** width *** |
| #if _LIBCPP_VERSION |
| // This limit isn't specified in the Standard. |
| static_assert(std::__format::__number_max == 2'147'483'647, |
| "Update the assert and the test."); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:2147483648}"), world); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:5000000000}"), world); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:10000000000}"), world); |
| #endif |
| |
| check_exception( |
| "A format-spec width field replacement should have a positive value", |
| STR("hello {:{}}"), world, 0); |
| check_exception( |
| "A format-spec arg-id replacement shouldn't have a negative value", |
| STR("hello {:{}}"), world, -1); |
| check_exception( |
| "A format-spec arg-id replacement exceeds the maximum supported value", |
| STR("hello {:{}}"), world, -1u); |
| check_exception("Argument index out of bounds", STR("hello {:{}}"), world); |
| check_exception( |
| "A format-spec arg-id replacement argument isn't an integral type", |
| STR("hello {:{}}"), world, universe); |
| check_exception( |
| "Using manual argument numbering in automatic argument numbering mode", |
| STR("hello {:{0}}"), world, 1); |
| check_exception( |
| "Using automatic argument numbering in manual argument numbering mode", |
| STR("hello {0:{}}"), world, 1); |
| |
| // *** precision *** |
| check_exception("A format-spec precision field shouldn't have a leading zero", |
| STR("hello {:.01}"), world); |
| |
| #if _LIBCPP_VERSION |
| // This limit isn't specified in the Standard. |
| static_assert(std::__format::__number_max == 2'147'483'647, |
| "Update the assert and the test."); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:.2147483648}"), world); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:.5000000000}"), world); |
| check_exception("The numeric value of the format-spec is too large", |
| STR("{:.10000000000}"), world); |
| #endif |
| |
| // Precision 0 allowed, but not useful for string arguments. |
| check(STR("hello "), STR("hello {:.{}}"), world, 0); |
| check_exception( |
| "A format-spec arg-id replacement shouldn't have a negative value", |
| STR("hello {:.{}}"), world, -1); |
| check_exception( |
| "A format-spec arg-id replacement exceeds the maximum supported value", |
| STR("hello {:.{}}"), world, -1u); |
| check_exception("Argument index out of bounds", STR("hello {:.{}}"), world); |
| check_exception( |
| "A format-spec arg-id replacement argument isn't an integral type", |
| STR("hello {:.{}}"), world, universe); |
| check_exception( |
| "Using manual argument numbering in automatic argument numbering mode", |
| STR("hello {:.{0}}"), world, 1); |
| check_exception( |
| "Using automatic argument numbering in manual argument numbering mode", |
| STR("hello {0:.{}}"), world, 1); |
| |
| // *** locale-specific form *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("hello {:L}"), world); |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("s")) |
| check_exception( |
| "The format-spec type has a type not supported for a string argument", |
| fmt, world); |
| } |
| |
| template <class CharT, class TestFunction> |
| void format_test_string_unicode(TestFunction check) { |
| #ifndef _LIBCPP_HAS_NO_UNICODE |
| // ß requires one column |
| check(STR("aßc"), STR("{}"), STR("aßc")); |
| |
| check(STR("aßc"), STR("{:.3}"), STR("aßc")); |
| check(STR("aß"), STR("{:.2}"), STR("aßc")); |
| check(STR("a"), STR("{:.1}"), STR("aßc")); |
| |
| check(STR("aßc"), STR("{:3.3}"), STR("aßc")); |
| check(STR("aß"), STR("{:2.2}"), STR("aßc")); |
| check(STR("a"), STR("{:1.1}"), STR("aßc")); |
| |
| check(STR("aßc---"), STR("{:-<6}"), STR("aßc")); |
| check(STR("-aßc--"), STR("{:-^6}"), STR("aßc")); |
| check(STR("---aßc"), STR("{:->6}"), STR("aßc")); |
| |
| // \u1000 requires two columns |
| check(STR("a\u1110c"), STR("{}"), STR("a\u1110c")); |
| |
| check(STR("a\u1100c"), STR("{:.4}"), STR("a\u1100c")); |
| check(STR("a\u1100"), STR("{:.3}"), STR("a\u1100c")); |
| check(STR("a"), STR("{:.2}"), STR("a\u1100c")); |
| check(STR("a"), STR("{:.1}"), STR("a\u1100c")); |
| |
| check(STR("a\u1100c"), STR("{:-<4.4}"), STR("a\u1100c")); |
| check(STR("a\u1100"), STR("{:-<3.3}"), STR("a\u1100c")); |
| check(STR("a-"), STR("{:-<2.2}"), STR("a\u1100c")); |
| check(STR("a"), STR("{:-<1.1}"), STR("a\u1100c")); |
| |
| check(STR("a\u1110c---"), STR("{:-<7}"), STR("a\u1110c")); |
| check(STR("-a\u1110c--"), STR("{:-^7}"), STR("a\u1110c")); |
| check(STR("---a\u1110c"), STR("{:->7}"), STR("a\u1110c")); |
| #else |
| (void)check; |
| #endif |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_string_tests(TestFunction check, ExceptionTest check_exception) { |
| std::basic_string<CharT> world = STR("world"); |
| std::basic_string<CharT> universe = STR("universe"); |
| |
| // Testing the char const[] is a bit tricky due to array to pointer decay. |
| // Since there are separate tests in format.formatter.spec the array is not |
| // tested here. |
| format_test_string<CharT>(world.c_str(), universe.c_str(), check, |
| check_exception); |
| format_test_string<CharT>(const_cast<CharT*>(world.c_str()), |
| const_cast<CharT*>(universe.c_str()), check, |
| check_exception); |
| format_test_string<CharT>(std::basic_string_view<CharT>(world), |
| std::basic_string_view<CharT>(universe), check, |
| check_exception); |
| format_test_string<CharT>(world, universe, check, check_exception); |
| format_test_string_unicode<CharT>(check); |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_bool(TestFunction check, ExceptionTest check_exception) { |
| |
| // *** align-fill & width *** |
| check(STR("answer is 'true '"), STR("answer is '{:7}'"), true); |
| check(STR("answer is ' true'"), STR("answer is '{:>7}'"), true); |
| check(STR("answer is 'true '"), STR("answer is '{:<7}'"), true); |
| check(STR("answer is ' true '"), STR("answer is '{:^7}'"), true); |
| |
| check(STR("answer is 'false '"), STR("answer is '{:8s}'"), false); |
| check(STR("answer is ' false'"), STR("answer is '{:>8s}'"), false); |
| check(STR("answer is 'false '"), STR("answer is '{:<8s}'"), false); |
| check(STR("answer is ' false '"), STR("answer is '{:^8s}'"), false); |
| |
| check(STR("answer is '---true'"), STR("answer is '{:->7}'"), true); |
| check(STR("answer is 'true---'"), STR("answer is '{:-<7}'"), true); |
| check(STR("answer is '-true--'"), STR("answer is '{:-^7}'"), true); |
| |
| check(STR("answer is '---false'"), STR("answer is '{:->8s}'"), false); |
| check(STR("answer is 'false---'"), STR("answer is '{:-<8s}'"), false); |
| check(STR("answer is '-false--'"), STR("answer is '{:-^8s}'"), false); |
| |
| // *** Sign *** |
| check_exception("A sign field isn't allowed in this format-spec", STR("{:-}"), |
| true); |
| check_exception("A sign field isn't allowed in this format-spec", STR("{:+}"), |
| true); |
| check_exception("A sign field isn't allowed in this format-spec", STR("{: }"), |
| true); |
| |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:-s}"), true); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:+s}"), true); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{: s}"), true); |
| |
| // *** alternate form *** |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("{:#}"), true); |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("{:#s}"), true); |
| |
| // *** zero-padding *** |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("{:0}"), true); |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("{:0s}"), true); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42}"), true); |
| |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.s}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0s}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42s}"), true); |
| |
| // *** locale-specific form *** |
| // See locale-specific_form.pass.cpp |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("bBcdosxX")) |
| check_exception( |
| "The format-spec type has a type not supported for a bool argument", |
| fmt, true); |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_bool_as_char(TestFunction check, |
| ExceptionTest check_exception) { |
| // *** align-fill & width *** |
| check(STR("answer is '\1 '"), STR("answer is '{:6c}'"), true); |
| check(STR("answer is ' \1'"), STR("answer is '{:>6c}'"), true); |
| check(STR("answer is '\1 '"), STR("answer is '{:<6c}'"), true); |
| check(STR("answer is ' \1 '"), STR("answer is '{:^6c}'"), true); |
| |
| check(STR("answer is '-----\1'"), STR("answer is '{:->6c}'"), true); |
| check(STR("answer is '\1-----'"), STR("answer is '{:-<6c}'"), true); |
| check(STR("answer is '--\1---'"), STR("answer is '{:-^6c}'"), true); |
| |
| check(std::basic_string<CharT>(CSTR("answer is '\0 '"), 18), |
| STR("answer is '{:6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is '\0 '"), 18), |
| STR("answer is '{:6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is ' \0'"), 18), |
| STR("answer is '{:>6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is '\0 '"), 18), |
| STR("answer is '{:<6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is ' \0 '"), 18), |
| STR("answer is '{:^6c}'"), false); |
| |
| check(std::basic_string<CharT>(CSTR("answer is '-----\0'"), 18), |
| STR("answer is '{:->6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is '\0-----'"), 18), |
| STR("answer is '{:-<6c}'"), false); |
| check(std::basic_string<CharT>(CSTR("answer is '--\0---'"), 18), |
| STR("answer is '{:-^6c}'"), false); |
| |
| // *** Sign *** |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:-c}"), true); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:+c}"), true); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{: c}"), true); |
| |
| // *** alternate form *** |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("{:#c}"), true); |
| |
| // *** zero-padding *** |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("{:0c}"), true); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.c}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0c}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42c}"), true); |
| |
| // *** locale-specific form *** |
| // Note it has no effect but it's allowed. |
| check(STR("answer is '*'"), STR("answer is '{:Lc}'"), '*'); |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("bBcdosxX")) |
| check_exception( |
| "The format-spec type has a type not supported for a bool argument", |
| fmt, true); |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_bool_as_integer(TestFunction check, |
| ExceptionTest check_exception) { |
| // *** align-fill & width *** |
| check(STR("answer is '1'"), STR("answer is '{:<1d}'"), true); |
| check(STR("answer is '1 '"), STR("answer is '{:<2d}'"), true); |
| check(STR("answer is '0 '"), STR("answer is '{:<2d}'"), false); |
| |
| check(STR("answer is ' 1'"), STR("answer is '{:6d}'"), true); |
| check(STR("answer is ' 1'"), STR("answer is '{:>6d}'"), true); |
| check(STR("answer is '1 '"), STR("answer is '{:<6d}'"), true); |
| check(STR("answer is ' 1 '"), STR("answer is '{:^6d}'"), true); |
| |
| check(STR("answer is '*****0'"), STR("answer is '{:*>6d}'"), false); |
| check(STR("answer is '0*****'"), STR("answer is '{:*<6d}'"), false); |
| check(STR("answer is '**0***'"), STR("answer is '{:*^6d}'"), false); |
| |
| // Test whether zero padding is ignored |
| check(STR("answer is ' 1'"), STR("answer is '{:>06d}'"), true); |
| check(STR("answer is '1 '"), STR("answer is '{:<06d}'"), true); |
| check(STR("answer is ' 1 '"), STR("answer is '{:^06d}'"), true); |
| |
| // *** Sign *** |
| check(STR("answer is 1"), STR("answer is {:d}"), true); |
| check(STR("answer is 0"), STR("answer is {:-d}"), false); |
| check(STR("answer is +1"), STR("answer is {:+d}"), true); |
| check(STR("answer is 0"), STR("answer is {: d}"), false); |
| |
| // *** alternate form *** |
| check(STR("answer is +1"), STR("answer is {:+#d}"), true); |
| check(STR("answer is +1"), STR("answer is {:+b}"), true); |
| check(STR("answer is +0b1"), STR("answer is {:+#b}"), true); |
| check(STR("answer is +0B1"), STR("answer is {:+#B}"), true); |
| check(STR("answer is +1"), STR("answer is {:+o}"), true); |
| check(STR("answer is +01"), STR("answer is {:+#o}"), true); |
| check(STR("answer is +1"), STR("answer is {:+x}"), true); |
| check(STR("answer is +0x1"), STR("answer is {:+#x}"), true); |
| check(STR("answer is +1"), STR("answer is {:+X}"), true); |
| check(STR("answer is +0X1"), STR("answer is {:+#X}"), true); |
| |
| check(STR("answer is 0"), STR("answer is {:#d}"), false); |
| check(STR("answer is 0"), STR("answer is {:b}"), false); |
| check(STR("answer is 0b0"), STR("answer is {:#b}"), false); |
| check(STR("answer is 0B0"), STR("answer is {:#B}"), false); |
| check(STR("answer is 0"), STR("answer is {:o}"), false); |
| check(STR("answer is 0"), STR("answer is {:#o}"), false); |
| check(STR("answer is 0"), STR("answer is {:x}"), false); |
| check(STR("answer is 0x0"), STR("answer is {:#x}"), false); |
| check(STR("answer is 0"), STR("answer is {:X}"), false); |
| check(STR("answer is 0X0"), STR("answer is {:#X}"), false); |
| |
| // *** zero-padding & width *** |
| check(STR("answer is +00000000001"), STR("answer is {:+#012d}"), true); |
| check(STR("answer is +00000000001"), STR("answer is {:+012b}"), true); |
| check(STR("answer is +0b000000001"), STR("answer is {:+#012b}"), true); |
| check(STR("answer is +0B000000001"), STR("answer is {:+#012B}"), true); |
| check(STR("answer is +00000000001"), STR("answer is {:+012o}"), true); |
| check(STR("answer is +00000000001"), STR("answer is {:+#012o}"), true); |
| check(STR("answer is +00000000001"), STR("answer is {:+012x}"), true); |
| check(STR("answer is +0x000000001"), STR("answer is {:+#012x}"), true); |
| check(STR("answer is +00000000001"), STR("answer is {:+012X}"), true); |
| check(STR("answer is +0X000000001"), STR("answer is {:+#012X}"), true); |
| |
| check(STR("answer is 000000000000"), STR("answer is {:#012d}"), false); |
| check(STR("answer is 000000000000"), STR("answer is {:012b}"), false); |
| check(STR("answer is 0b0000000000"), STR("answer is {:#012b}"), false); |
| check(STR("answer is 0B0000000000"), STR("answer is {:#012B}"), false); |
| check(STR("answer is 000000000000"), STR("answer is {:012o}"), false); |
| check(STR("answer is 000000000000"), STR("answer is {:#012o}"), false); |
| check(STR("answer is 000000000000"), STR("answer is {:012x}"), false); |
| check(STR("answer is 0x0000000000"), STR("answer is {:#012x}"), false); |
| check(STR("answer is 000000000000"), STR("answer is {:012X}"), false); |
| check(STR("answer is 0X0000000000"), STR("answer is {:#012X}"), false); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0}"), true); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42}"), true); |
| |
| // *** locale-specific form *** |
| // See locale-specific_form.pass.cpp |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("bBcdosxX")) |
| check_exception( |
| "The format-spec type has a type not supported for a bool argument", |
| fmt, true); |
| } |
| |
| template <class I, class CharT, class TestFunction, class ExceptionTest> |
| void format_test_integer_as_integer(TestFunction check, |
| ExceptionTest check_exception) { |
| // *** align-fill & width *** |
| check(STR("answer is '42'"), STR("answer is '{:<1}'"), I(42)); |
| check(STR("answer is '42'"), STR("answer is '{:<2}'"), I(42)); |
| check(STR("answer is '42 '"), STR("answer is '{:<3}'"), I(42)); |
| |
| check(STR("answer is ' 42'"), STR("answer is '{:7}'"), I(42)); |
| check(STR("answer is ' 42'"), STR("answer is '{:>7}'"), I(42)); |
| check(STR("answer is '42 '"), STR("answer is '{:<7}'"), I(42)); |
| check(STR("answer is ' 42 '"), STR("answer is '{:^7}'"), I(42)); |
| |
| check(STR("answer is '*****42'"), STR("answer is '{:*>7}'"), I(42)); |
| check(STR("answer is '42*****'"), STR("answer is '{:*<7}'"), I(42)); |
| check(STR("answer is '**42***'"), STR("answer is '{:*^7}'"), I(42)); |
| |
| // Test whether zero padding is ignored |
| check(STR("answer is ' 42'"), STR("answer is '{:>07}'"), I(42)); |
| check(STR("answer is '42 '"), STR("answer is '{:<07}'"), I(42)); |
| check(STR("answer is ' 42 '"), STR("answer is '{:^07}'"), I(42)); |
| |
| // *** Sign *** |
| if constexpr (std::signed_integral<I>) |
| check(STR("answer is -42"), STR("answer is {}"), I(-42)); |
| check(STR("answer is 0"), STR("answer is {}"), I(0)); |
| check(STR("answer is 42"), STR("answer is {}"), I(42)); |
| |
| if constexpr (std::signed_integral<I>) |
| check(STR("answer is -42"), STR("answer is {:-}"), I(-42)); |
| check(STR("answer is 0"), STR("answer is {:-}"), I(0)); |
| check(STR("answer is 42"), STR("answer is {:-}"), I(42)); |
| |
| if constexpr (std::signed_integral<I>) |
| check(STR("answer is -42"), STR("answer is {:+}"), I(-42)); |
| check(STR("answer is +0"), STR("answer is {:+}"), I(0)); |
| check(STR("answer is +42"), STR("answer is {:+}"), I(42)); |
| |
| if constexpr (std::signed_integral<I>) |
| check(STR("answer is -42"), STR("answer is {: }"), I(-42)); |
| check(STR("answer is 0"), STR("answer is {: }"), I(0)); |
| check(STR("answer is 42"), STR("answer is {: }"), I(42)); |
| |
| // *** alternate form *** |
| if constexpr (std::signed_integral<I>) { |
| check(STR("answer is -42"), STR("answer is {:#}"), I(-42)); |
| check(STR("answer is -42"), STR("answer is {:#d}"), I(-42)); |
| check(STR("answer is -101010"), STR("answer is {:b}"), I(-42)); |
| check(STR("answer is -0b101010"), STR("answer is {:#b}"), I(-42)); |
| check(STR("answer is -0B101010"), STR("answer is {:#B}"), I(-42)); |
| check(STR("answer is -52"), STR("answer is {:o}"), I(-42)); |
| check(STR("answer is -052"), STR("answer is {:#o}"), I(-42)); |
| check(STR("answer is -2a"), STR("answer is {:x}"), I(-42)); |
| check(STR("answer is -0x2a"), STR("answer is {:#x}"), I(-42)); |
| check(STR("answer is -2A"), STR("answer is {:X}"), I(-42)); |
| check(STR("answer is -0X2A"), STR("answer is {:#X}"), I(-42)); |
| } |
| check(STR("answer is 0"), STR("answer is {:#}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:#d}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:b}"), I(0)); |
| check(STR("answer is 0b0"), STR("answer is {:#b}"), I(0)); |
| check(STR("answer is 0B0"), STR("answer is {:#B}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:o}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:#o}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:x}"), I(0)); |
| check(STR("answer is 0x0"), STR("answer is {:#x}"), I(0)); |
| check(STR("answer is 0"), STR("answer is {:X}"), I(0)); |
| check(STR("answer is 0X0"), STR("answer is {:#X}"), I(0)); |
| |
| check(STR("answer is +42"), STR("answer is {:+#}"), I(42)); |
| check(STR("answer is +42"), STR("answer is {:+#d}"), I(42)); |
| check(STR("answer is +101010"), STR("answer is {:+b}"), I(42)); |
| check(STR("answer is +0b101010"), STR("answer is {:+#b}"), I(42)); |
| check(STR("answer is +0B101010"), STR("answer is {:+#B}"), I(42)); |
| check(STR("answer is +52"), STR("answer is {:+o}"), I(42)); |
| check(STR("answer is +052"), STR("answer is {:+#o}"), I(42)); |
| check(STR("answer is +2a"), STR("answer is {:+x}"), I(42)); |
| check(STR("answer is +0x2a"), STR("answer is {:+#x}"), I(42)); |
| check(STR("answer is +2A"), STR("answer is {:+X}"), I(42)); |
| check(STR("answer is +0X2A"), STR("answer is {:+#X}"), I(42)); |
| |
| // *** zero-padding & width *** |
| if constexpr (std::signed_integral<I>) { |
| check(STR("answer is -00000000042"), STR("answer is {:#012}"), I(-42)); |
| check(STR("answer is -00000000042"), STR("answer is {:#012d}"), I(-42)); |
| check(STR("answer is -00000101010"), STR("answer is {:012b}"), I(-42)); |
| check(STR("answer is -0b000101010"), STR("answer is {:#012b}"), I(-42)); |
| check(STR("answer is -0B000101010"), STR("answer is {:#012B}"), I(-42)); |
| check(STR("answer is -00000000052"), STR("answer is {:012o}"), I(-42)); |
| check(STR("answer is -00000000052"), STR("answer is {:#012o}"), I(-42)); |
| check(STR("answer is -0000000002a"), STR("answer is {:012x}"), I(-42)); |
| check(STR("answer is -0x00000002a"), STR("answer is {:#012x}"), I(-42)); |
| check(STR("answer is -0000000002A"), STR("answer is {:012X}"), I(-42)); |
| check(STR("answer is -0X00000002A"), STR("answer is {:#012X}"), I(-42)); |
| } |
| |
| check(STR("answer is 000000000000"), STR("answer is {:#012}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:#012d}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:012b}"), I(0)); |
| check(STR("answer is 0b0000000000"), STR("answer is {:#012b}"), I(0)); |
| check(STR("answer is 0B0000000000"), STR("answer is {:#012B}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:012o}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:#012o}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:012x}"), I(0)); |
| check(STR("answer is 0x0000000000"), STR("answer is {:#012x}"), I(0)); |
| check(STR("answer is 000000000000"), STR("answer is {:012X}"), I(0)); |
| check(STR("answer is 0X0000000000"), STR("answer is {:#012X}"), I(0)); |
| |
| check(STR("answer is +00000000042"), STR("answer is {:+#012}"), I(42)); |
| check(STR("answer is +00000000042"), STR("answer is {:+#012d}"), I(42)); |
| check(STR("answer is +00000101010"), STR("answer is {:+012b}"), I(42)); |
| check(STR("answer is +0b000101010"), STR("answer is {:+#012b}"), I(42)); |
| check(STR("answer is +0B000101010"), STR("answer is {:+#012B}"), I(42)); |
| check(STR("answer is +00000000052"), STR("answer is {:+012o}"), I(42)); |
| check(STR("answer is +00000000052"), STR("answer is {:+#012o}"), I(42)); |
| check(STR("answer is +0000000002a"), STR("answer is {:+012x}"), I(42)); |
| check(STR("answer is +0x00000002a"), STR("answer is {:+#012x}"), I(42)); |
| check(STR("answer is +0000000002A"), STR("answer is {:+012X}"), I(42)); |
| check(STR("answer is +0X00000002A"), STR("answer is {:+#012X}"), I(42)); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.}"), I(0)); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0}"), I(0)); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42}"), I(0)); |
| |
| // *** locale-specific form *** |
| // See locale-specific_form.pass.cpp |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("bBcdoxX")) |
| check_exception( |
| "The format-spec type has a type not supported for an integer argument", |
| fmt, 42); |
| } |
| |
| template <class I, class CharT, class TestFunction, class ExceptionTest> |
| void format_test_integer_as_char(TestFunction check, |
| ExceptionTest check_exception) { |
| // *** align-fill & width *** |
| check(STR("answer is '* '"), STR("answer is '{:6c}'"), I(42)); |
| check(STR("answer is ' *'"), STR("answer is '{:>6c}'"), I(42)); |
| check(STR("answer is '* '"), STR("answer is '{:<6c}'"), I(42)); |
| check(STR("answer is ' * '"), STR("answer is '{:^6c}'"), I(42)); |
| |
| check(STR("answer is '-----*'"), STR("answer is '{:->6c}'"), I(42)); |
| check(STR("answer is '*-----'"), STR("answer is '{:-<6c}'"), I(42)); |
| check(STR("answer is '--*---'"), STR("answer is '{:-^6c}'"), I(42)); |
| |
| // *** Sign *** |
| check(STR("answer is *"), STR("answer is {:c}"), I(42)); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("answer is {:-c}"), I(42)); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("answer is {:+c}"), I(42)); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("answer is {: c}"), I(42)); |
| |
| // *** alternate form *** |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("answer is {:#c}"), I(42)); |
| |
| // *** zero-padding & width *** |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("answer is {:01c}"), I(42)); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.c}"), I(0)); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0c}"), I(0)); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42c}"), I(0)); |
| |
| // *** locale-specific form *** |
| // Note it has no effect but it's allowed. |
| check(STR("answer is '*'"), STR("answer is '{:Lc}'"), I(42)); |
| |
| // *** type *** |
| for (const auto& fmt : invalid_types<CharT>("bBcdoxX")) |
| check_exception( |
| "The format-spec type has a type not supported for an integer argument", |
| fmt, I(42)); |
| |
| // *** Validate range *** |
| // TODO FMT Update test after adding 128-bit support. |
| if constexpr (sizeof(I) <= sizeof(long long)) { |
| // The code has some duplications to keep the if statement readable. |
| if constexpr (std::signed_integral<CharT>) { |
| if constexpr (std::signed_integral<I> && sizeof(I) > sizeof(CharT)) { |
| check_exception("Integral value outside the range of the char type", |
| STR("{:c}"), std::numeric_limits<I>::min()); |
| check_exception("Integral value outside the range of the char type", |
| STR("{:c}"), std::numeric_limits<I>::max()); |
| } else if constexpr (std::unsigned_integral<I> && |
| sizeof(I) >= sizeof(CharT)) { |
| check_exception("Integral value outside the range of the char type", |
| STR("{:c}"), std::numeric_limits<I>::max()); |
| } |
| } else if constexpr (sizeof(I) > sizeof(CharT)) { |
| check_exception("Integral value outside the range of the char type", |
| STR("{:c}"), std::numeric_limits<I>::max()); |
| } |
| } |
| } |
| |
| template <class I, class CharT, class TestFunction, class ExceptionTest> |
| void format_test_integer(TestFunction check, ExceptionTest check_exception) { |
| format_test_integer_as_integer<I, CharT>(check, check_exception); |
| format_test_integer_as_char<I, CharT>(check, check_exception); |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_signed_integer(TestFunction check, |
| ExceptionTest check_exception) { |
| format_test_integer<signed char, CharT>(check, check_exception); |
| format_test_integer<short, CharT>(check, check_exception); |
| format_test_integer<int, CharT>(check, check_exception); |
| format_test_integer<long, CharT>(check, check_exception); |
| format_test_integer<long long, CharT>(check, check_exception); |
| #ifndef _LIBCPP_HAS_NO_INT128 |
| format_test_integer<__int128_t, CharT>(check, check_exception); |
| #endif |
| // *** check the minma and maxima *** |
| check(STR("-0b10000000"), STR("{:#b}"), std::numeric_limits<int8_t>::min()); |
| check(STR("-0200"), STR("{:#o}"), std::numeric_limits<int8_t>::min()); |
| check(STR("-128"), STR("{:#}"), std::numeric_limits<int8_t>::min()); |
| check(STR("-0x80"), STR("{:#x}"), std::numeric_limits<int8_t>::min()); |
| |
| check(STR("-0b1000000000000000"), STR("{:#b}"), |
| std::numeric_limits<int16_t>::min()); |
| check(STR("-0100000"), STR("{:#o}"), std::numeric_limits<int16_t>::min()); |
| check(STR("-32768"), STR("{:#}"), std::numeric_limits<int16_t>::min()); |
| check(STR("-0x8000"), STR("{:#x}"), std::numeric_limits<int16_t>::min()); |
| |
| check(STR("-0b10000000000000000000000000000000"), STR("{:#b}"), |
| std::numeric_limits<int32_t>::min()); |
| check(STR("-020000000000"), STR("{:#o}"), |
| std::numeric_limits<int32_t>::min()); |
| check(STR("-2147483648"), STR("{:#}"), std::numeric_limits<int32_t>::min()); |
| check(STR("-0x80000000"), STR("{:#x}"), std::numeric_limits<int32_t>::min()); |
| |
| check(STR("-0b100000000000000000000000000000000000000000000000000000000000000" |
| "0"), |
| STR("{:#b}"), std::numeric_limits<int64_t>::min()); |
| check(STR("-01000000000000000000000"), STR("{:#o}"), |
| std::numeric_limits<int64_t>::min()); |
| check(STR("-9223372036854775808"), STR("{:#}"), |
| std::numeric_limits<int64_t>::min()); |
| check(STR("-0x8000000000000000"), STR("{:#x}"), |
| std::numeric_limits<int64_t>::min()); |
| |
| check(STR("0b1111111"), STR("{:#b}"), std::numeric_limits<int8_t>::max()); |
| check(STR("0177"), STR("{:#o}"), std::numeric_limits<int8_t>::max()); |
| check(STR("127"), STR("{:#}"), std::numeric_limits<int8_t>::max()); |
| check(STR("0x7f"), STR("{:#x}"), std::numeric_limits<int8_t>::max()); |
| |
| check(STR("0b111111111111111"), STR("{:#b}"), |
| std::numeric_limits<int16_t>::max()); |
| check(STR("077777"), STR("{:#o}"), std::numeric_limits<int16_t>::max()); |
| check(STR("32767"), STR("{:#}"), std::numeric_limits<int16_t>::max()); |
| check(STR("0x7fff"), STR("{:#x}"), std::numeric_limits<int16_t>::max()); |
| |
| check(STR("0b1111111111111111111111111111111"), STR("{:#b}"), |
| std::numeric_limits<int32_t>::max()); |
| check(STR("017777777777"), STR("{:#o}"), std::numeric_limits<int32_t>::max()); |
| check(STR("2147483647"), STR("{:#}"), std::numeric_limits<int32_t>::max()); |
| check(STR("0x7fffffff"), STR("{:#x}"), std::numeric_limits<int32_t>::max()); |
| |
| check( |
| STR("0b111111111111111111111111111111111111111111111111111111111111111"), |
| STR("{:#b}"), std::numeric_limits<int64_t>::max()); |
| check(STR("0777777777777777777777"), STR("{:#o}"), |
| std::numeric_limits<int64_t>::max()); |
| check(STR("9223372036854775807"), STR("{:#}"), |
| std::numeric_limits<int64_t>::max()); |
| check(STR("0x7fffffffffffffff"), STR("{:#x}"), |
| std::numeric_limits<int64_t>::max()); |
| |
| // TODO FMT Add __int128_t test after implementing full range. |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_unsigned_integer(TestFunction check, |
| ExceptionTest check_exception) { |
| format_test_integer<unsigned char, CharT>(check, check_exception); |
| format_test_integer<unsigned short, CharT>(check, check_exception); |
| format_test_integer<unsigned, CharT>(check, check_exception); |
| format_test_integer<unsigned long, CharT>(check, check_exception); |
| format_test_integer<unsigned long long, CharT>(check, check_exception); |
| #ifndef _LIBCPP_HAS_NO_INT128 |
| format_test_integer<__uint128_t, CharT>(check, check_exception); |
| #endif |
| // *** test the maxima *** |
| check(STR("0b11111111"), STR("{:#b}"), std::numeric_limits<uint8_t>::max()); |
| check(STR("0377"), STR("{:#o}"), std::numeric_limits<uint8_t>::max()); |
| check(STR("255"), STR("{:#}"), std::numeric_limits<uint8_t>::max()); |
| check(STR("0xff"), STR("{:#x}"), std::numeric_limits<uint8_t>::max()); |
| |
| check(STR("0b1111111111111111"), STR("{:#b}"), |
| std::numeric_limits<uint16_t>::max()); |
| check(STR("0177777"), STR("{:#o}"), std::numeric_limits<uint16_t>::max()); |
| check(STR("65535"), STR("{:#}"), std::numeric_limits<uint16_t>::max()); |
| check(STR("0xffff"), STR("{:#x}"), std::numeric_limits<uint16_t>::max()); |
| |
| check(STR("0b11111111111111111111111111111111"), STR("{:#b}"), |
| std::numeric_limits<uint32_t>::max()); |
| check(STR("037777777777"), STR("{:#o}"), |
| std::numeric_limits<uint32_t>::max()); |
| check(STR("4294967295"), STR("{:#}"), std::numeric_limits<uint32_t>::max()); |
| check(STR("0xffffffff"), STR("{:#x}"), std::numeric_limits<uint32_t>::max()); |
| |
| check( |
| STR("0b1111111111111111111111111111111111111111111111111111111111111111"), |
| STR("{:#b}"), std::numeric_limits<uint64_t>::max()); |
| check(STR("01777777777777777777777"), STR("{:#o}"), |
| std::numeric_limits<uint64_t>::max()); |
| check(STR("18446744073709551615"), STR("{:#}"), |
| std::numeric_limits<uint64_t>::max()); |
| check(STR("0xffffffffffffffff"), STR("{:#x}"), |
| std::numeric_limits<uint64_t>::max()); |
| |
| // TODO FMT Add __uint128_t test after implementing full range. |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_char(TestFunction check, ExceptionTest check_exception) { |
| |
| // ***** Char type ***** |
| // *** align-fill & width *** |
| check(STR("answer is '* '"), STR("answer is '{:6}'"), CharT('*')); |
| check(STR("answer is ' *'"), STR("answer is '{:>6}'"), CharT('*')); |
| check(STR("answer is '* '"), STR("answer is '{:<6}'"), CharT('*')); |
| check(STR("answer is ' * '"), STR("answer is '{:^6}'"), CharT('*')); |
| |
| check(STR("answer is '* '"), STR("answer is '{:6c}'"), CharT('*')); |
| check(STR("answer is ' *'"), STR("answer is '{:>6c}'"), CharT('*')); |
| check(STR("answer is '* '"), STR("answer is '{:<6c}'"), CharT('*')); |
| check(STR("answer is ' * '"), STR("answer is '{:^6c}'"), CharT('*')); |
| |
| check(STR("answer is '-----*'"), STR("answer is '{:->6}'"), CharT('*')); |
| check(STR("answer is '*-----'"), STR("answer is '{:-<6}'"), CharT('*')); |
| check(STR("answer is '--*---'"), STR("answer is '{:-^6}'"), CharT('*')); |
| |
| check(STR("answer is '-----*'"), STR("answer is '{:->6c}'"), CharT('*')); |
| check(STR("answer is '*-----'"), STR("answer is '{:-<6c}'"), CharT('*')); |
| check(STR("answer is '--*---'"), STR("answer is '{:-^6c}'"), CharT('*')); |
| |
| // *** Sign *** |
| check_exception("A sign field isn't allowed in this format-spec", STR("{:-}"), |
| CharT('*')); |
| check_exception("A sign field isn't allowed in this format-spec", STR("{:+}"), |
| CharT('*')); |
| check_exception("A sign field isn't allowed in this format-spec", STR("{: }"), |
| CharT('*')); |
| |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:-c}"), CharT('*')); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{:+c}"), CharT('*')); |
| check_exception("A sign field isn't allowed in this format-spec", |
| STR("{: c}"), CharT('*')); |
| |
| // *** alternate form *** |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("{:#}"), CharT('*')); |
| check_exception("An alternate form field isn't allowed in this format-spec", |
| STR("{:#c}"), CharT('*')); |
| |
| // *** zero-padding *** |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("{:0}"), CharT('*')); |
| check_exception("A zero-padding field isn't allowed in this format-spec", |
| STR("{:0c}"), CharT('*')); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42}"), CharT('*')); |
| |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.c}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0c}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42c}"), CharT('*')); |
| |
| // *** locale-specific form *** |
| // Note it has no effect but it's allowed. |
| check(STR("answer is '*'"), STR("answer is '{:L}'"), '*'); |
| check(STR("answer is '*'"), STR("answer is '{:Lc}'"), '*'); |
| |
| // *** 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, CharT('*')); |
| } |
| |
| template <class CharT, class TestFunction, class ExceptionTest> |
| void format_test_char_as_integer(TestFunction check, |
| ExceptionTest check_exception) { |
| // *** align-fill & width *** |
| check(STR("answer is '42'"), STR("answer is '{:<1d}'"), CharT('*')); |
| |
| check(STR("answer is '42'"), STR("answer is '{:<2d}'"), CharT('*')); |
| check(STR("answer is '42 '"), STR("answer is '{:<3d}'"), CharT('*')); |
| |
| check(STR("answer is ' 42'"), STR("answer is '{:7d}'"), CharT('*')); |
| check(STR("answer is ' 42'"), STR("answer is '{:>7d}'"), CharT('*')); |
| check(STR("answer is '42 '"), STR("answer is '{:<7d}'"), CharT('*')); |
| check(STR("answer is ' 42 '"), STR("answer is '{:^7d}'"), CharT('*')); |
| |
| check(STR("answer is '*****42'"), STR("answer is '{:*>7d}'"), CharT('*')); |
| check(STR("answer is '42*****'"), STR("answer is '{:*<7d}'"), CharT('*')); |
| check(STR("answer is '**42***'"), STR("answer is '{:*^7d}'"), CharT('*')); |
| |
| // Test whether zero padding is ignored |
| check(STR("answer is ' 42'"), STR("answer is '{:>07d}'"), CharT('*')); |
| check(STR("answer is '42 '"), STR("answer is '{:<07d}'"), CharT('*')); |
| check(STR("answer is ' 42 '"), STR("answer is '{:^07d}'"), CharT('*')); |
| |
| // *** Sign *** |
| check(STR("answer is 42"), STR("answer is {:d}"), CharT('*')); |
| check(STR("answer is 42"), STR("answer is {:-d}"), CharT('*')); |
| check(STR("answer is +42"), STR("answer is {:+d}"), CharT('*')); |
| check(STR("answer is 42"), STR("answer is {: d}"), CharT('*')); |
| |
| // *** alternate form *** |
| check(STR("answer is +42"), STR("answer is {:+#d}"), CharT('*')); |
| check(STR("answer is +101010"), STR("answer is {:+b}"), CharT('*')); |
| check(STR("answer is +0b101010"), STR("answer is {:+#b}"), CharT('*')); |
| check(STR("answer is +0B101010"), STR("answer is {:+#B}"), CharT('*')); |
| check(STR("answer is +52"), STR("answer is {:+o}"), CharT('*')); |
| check(STR("answer is +052"), STR("answer is {:+#o}"), CharT('*')); |
| check(STR("answer is +2a"), STR("answer is {:+x}"), CharT('*')); |
| check(STR("answer is +0x2a"), STR("answer is {:+#x}"), CharT('*')); |
| check(STR("answer is +2A"), STR("answer is {:+X}"), CharT('*')); |
| check(STR("answer is +0X2A"), STR("answer is {:+#X}"), CharT('*')); |
| |
| // *** zero-padding & width *** |
| check(STR("answer is +00000000042"), STR("answer is {:+#012d}"), CharT('*')); |
| check(STR("answer is +00000101010"), STR("answer is {:+012b}"), CharT('*')); |
| check(STR("answer is +0b000101010"), STR("answer is {:+#012b}"), CharT('*')); |
| check(STR("answer is +0B000101010"), STR("answer is {:+#012B}"), CharT('*')); |
| check(STR("answer is +00000000052"), STR("answer is {:+012o}"), CharT('*')); |
| check(STR("answer is +00000000052"), STR("answer is {:+#012o}"), CharT('*')); |
| check(STR("answer is +0000000002a"), STR("answer is {:+012x}"), CharT('*')); |
| check(STR("answer is +0x00000002a"), STR("answer is {:+#012x}"), CharT('*')); |
| check(STR("answer is +0000000002A"), STR("answer is {:+012X}"), CharT('*')); |
| |
| check(STR("answer is +0X00000002A"), STR("answer is {:+#012X}"), CharT('*')); |
| |
| // *** precision *** |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.d}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.0d}"), CharT('*')); |
| check_exception("The format-spec should consume the input or end with a '}'", |
| STR("{:.42d}"), CharT('*')); |
| |
| // *** locale-specific form *** |
| // See locale-specific_form.pass.cpp |
| |
| // *** 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 CharT, class TestFunction, class ExceptionTest> |
| void format_tests(TestFunction check, ExceptionTest check_exception) { |
| // *** Test escaping *** |
| check(STR("{"), STR("{{")); |
| check(STR("}"), STR("}}")); |
| |
| // *** Test argument ID *** |
| check(STR("hello false true"), STR("hello {0:} {1:}"), false, true); |
| check(STR("hello true false"), STR("hello {1:} {0:}"), false, true); |
| |
| // ** Test invalid format strings *** |
| check_exception("The format string terminates at a '{'", STR("{")); |
| check_exception("The replacement field misses a terminating '}'", STR("{:"), |
| 42); |
| |
| check_exception("The format string contains an invalid escape sequence", |
| STR("}")); |
| check_exception("The format string contains an invalid escape sequence", |
| STR("{:}-}"), 42); |
| |
| check_exception("The format string contains an invalid escape sequence", |
| STR("} ")); |
| |
| check_exception( |
| "The arg-id of the format-spec starts with an invalid character", |
| STR("{-"), 42); |
| check_exception("Argument index out of bounds", STR("hello {}")); |
| check_exception("Argument index out of bounds", STR("hello {0}")); |
| check_exception("Argument index out of bounds", STR("hello {1}"), 42); |
| |
| // *** Test char format argument *** |
| // The `char` to `wchar_t` formatting is tested separately. |
| check(STR("hello 09azAZ!"), STR("hello {}{}{}{}{}{}{}"), CharT('0'), |
| CharT('9'), CharT('a'), CharT('z'), CharT('A'), CharT('Z'), CharT('!')); |
| |
| format_test_char<CharT>(check, check_exception); |
| format_test_char_as_integer<CharT>(check, check_exception); |
| |
| // *** Test string format argument *** |
| { |
| CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'), |
| CharT('A'), CharT('Z'), CharT('!'), 0}; |
| CharT* data = buffer; |
| check(STR("hello 09azAZ!"), STR("hello {}"), data); |
| } |
| { |
| CharT buffer[] = {CharT('0'), CharT('9'), CharT('a'), CharT('z'), |
| CharT('A'), CharT('Z'), CharT('!'), 0}; |
| const CharT* data = buffer; |
| check(STR("hello 09azAZ!"), STR("hello {}"), data); |
| } |
| { |
| std::basic_string<CharT> data = STR("world"); |
| check(STR("hello world"), STR("hello {}"), data); |
| } |
| { |
| std::basic_string<CharT> buffer = STR("world"); |
| std::basic_string_view<CharT> data = buffer; |
| check(STR("hello world"), STR("hello {}"), data); |
| } |
| format_string_tests<CharT>(check, check_exception); |
| |
| // *** Test Boolean format argument *** |
| check(STR("hello false true"), STR("hello {} {}"), false, true); |
| |
| format_test_bool<CharT>(check, check_exception); |
| format_test_bool_as_char<CharT>(check, check_exception); |
| format_test_bool_as_integer<CharT>(check, check_exception); |
| |
| // *** Test signed integral format argument *** |
| check(STR("hello 42"), STR("hello {}"), static_cast<signed char>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<short>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<int>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<long>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<long long>(42)); |
| #ifndef _LIBCPP_HAS_NO_INT128 |
| check(STR("hello 42"), STR("hello {}"), static_cast<__int128_t>(42)); |
| { |
| // Note 128-bit support is only partly implemented test the range |
| // conditions here. |
| std::basic_string<CharT> min = |
| std::format(STR("{}"), std::numeric_limits<long long>::min()); |
| check(min, STR("{}"), |
| static_cast<__int128_t>(std::numeric_limits<long long>::min())); |
| std::basic_string<CharT> max = |
| std::format(STR("{}"), std::numeric_limits<long long>::max()); |
| check(max, STR("{}"), |
| static_cast<__int128_t>(std::numeric_limits<long long>::max())); |
| check_exception( |
| "128-bit value is outside of implemented range", STR("{}"), |
| static_cast<__int128_t>(std::numeric_limits<long long>::min()) - 1); |
| check_exception( |
| "128-bit value is outside of implemented range", STR("{}"), |
| static_cast<__int128_t>(std::numeric_limits<long long>::max()) + 1); |
| } |
| #endif |
| format_test_signed_integer<CharT>(check, check_exception); |
| |
| // ** Test unsigned integral format argument *** |
| check(STR("hello 42"), STR("hello {}"), static_cast<unsigned char>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<unsigned short>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<unsigned>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<unsigned long>(42)); |
| check(STR("hello 42"), STR("hello {}"), static_cast<unsigned long long>(42)); |
| #ifndef _LIBCPP_HAS_NO_INT128 |
| check(STR("hello 42"), STR("hello {}"), static_cast<__uint128_t>(42)); |
| { |
| // Note 128-bit support is only partly implemented test the range |
| // conditions here. |
| std::basic_string<CharT> max = |
| std::format(STR("{}"), std::numeric_limits<unsigned long long>::max()); |
| check(max, STR("{}"), |
| static_cast<__uint128_t>( |
| std::numeric_limits<unsigned long long>::max())); |
| check_exception("128-bit value is outside of implemented range", STR("{}"), |
| static_cast<__uint128_t>( |
| std::numeric_limits<unsigned long long>::max()) + |
| 1); |
| } |
| #endif |
| format_test_unsigned_integer<CharT>(check, check_exception); |
| |
| // *** Test floating point format argument *** |
| // TODO FMT Enable after floating-point support has been enabled |
| #if 0 |
| check(STR("hello 42.000000"), STR("hello {}"), static_cast<float>(42)); |
| check(STR("hello 42.000000"), STR("hello {}"), static_cast<double>(42)); |
| check(STR("hello 42.000000"), STR("hello {}"), static_cast<long double>(42)); |
| #endif |
| } |
| |
| #ifndef TEST_HAS_NO_WIDE_CHARACTERS |
| template <class TestFunction> |
| void format_tests_char_to_wchar_t(TestFunction check) { |
| using CharT = wchar_t; |
| check(STR("hello 09azA"), STR("hello {}{}{}{}{}"), '0', '9', 'a', 'z', 'A'); |
| } |
| #endif |
| |
| #endif |
