libcxx/test/std/utilities/format/format.tuple/format.functions.tests.h

   1 //===----------------------------------------------------------------------===//
   2 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   3 // See https://llvm.org/LICENSE.txt for license information.
   4 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   5 //
   6 //===----------------------------------------------------------------------===//
   7
   8 #ifndef TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
   9 #define TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H
  10
  11 #include <concepts>
  12 #include <format>
  13 #include <tuple>
  14
  15 #include "format.functions.common.h"
  16
  17 enum class color { black, red, gold };
  18
  19 template <class CharT>
  20 struct std::formatter<color, CharT> : std::formatter<basic_string_view<CharT>, CharT> {
  21   static constexpr basic_string_view<CharT> color_names[] = {SV("black"), SV("red"), SV("gold")};
  22   auto format(color c, auto& ctx) const {
  23     return formatter<basic_string_view<CharT>, CharT>::format(color_names[static_cast<int>(c)], ctx);
  24   }
  25 };
  26
  27 //
  28 // Generic tests for a tuple and pair with two elements.
  29 //
  30 template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
  31 void test_tuple_or_pair_int_int(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
  32   check(SV("(42, 99)"), SV("{}"), input);
  33
  34   // *** align-fill & width ***
  35   check(SV("(42, 99)     "), SV("{:13}"), input);
  36   check(SV("(42, 99)*****"), SV("{:*<13}"), input);
  37   check(SV("__(42, 99)___"), SV("{:_^13}"), input);
  38   check(SV("#####(42, 99)"), SV("{:#>13}"), input);
  39
  40   check(SV("(42, 99)     "), SV("{:{}}"), input, 13);
  41   check(SV("(42, 99)*****"), SV("{:*<{}}"), input, 13);
  42   check(SV("__(42, 99)___"), SV("{:_^{}}"), input, 13);
  43   check(SV("#####(42, 99)"), SV("{:#>{}}"), input, 13);
  44
  45   check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
  46   check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
  47   check_exception("The fill option contains an invalid value", SV("{::<}"), input);
  48
  49   // *** sign ***
  50   check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
  51   check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
  52   check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
  53
  54   // *** alternate form ***
  55   check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
  56
  57   // *** zero-padding ***
  58   check_exception("The width option should not have a leading zero", SV("{:0}"), input);
  59
  60   // *** precision ***
  61   check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
  62
  63   // *** locale-specific form ***
  64   check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
  65
  66   // *** type ***
  67   check(SV("__42: 99___"), SV("{:_^11m}"), input);
  68   check(SV("__42, 99___"), SV("{:_^11n}"), input);
  69
  70   for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
  71     check_exception("The format specifier should consume the input or end with a '}'",
  72                     std::basic_string_view{STR("{:") + c + STR("}")},
  73                     input);
  74   }
  75 }
  76
  77 template <class CharT, class TestFunction, class ExceptionTest, class TupleOrPair>
  78 void test_tuple_or_pair_int_string(TestFunction check, ExceptionTest check_exception, TupleOrPair&& input) {
  79   check(SV("(42, \"hello\")"), SV("{}"), input);
  80
  81   // *** align-fill & width ***
  82   check(SV("(42, \"hello\")     "), SV("{:18}"), input);
  83   check(SV("(42, \"hello\")*****"), SV("{:*<18}"), input);
  84   check(SV("__(42, \"hello\")___"), SV("{:_^18}"), input);
  85   check(SV("#####(42, \"hello\")"), SV("{:#>18}"), input);
  86
  87   check(SV("(42, \"hello\")     "), SV("{:{}}"), input, 18);
  88   check(SV("(42, \"hello\")*****"), SV("{:*<{}}"), input, 18);
  89   check(SV("__(42, \"hello\")___"), SV("{:_^{}}"), input, 18);
  90   check(SV("#####(42, \"hello\")"), SV("{:#>{}}"), input, 18);
  91
  92   check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
  93   check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
  94   check_exception("The fill option contains an invalid value", SV("{::<}"), input);
  95
  96   // *** sign ***
  97   check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
  98   check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
  99   check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 100
 101   // *** alternate form ***
 102   check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 103
 104   // *** zero-padding ***
 105   check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 106
 107   // *** precision ***
 108   check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 109
 110   // *** locale-specific form ***
 111   check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 112
 113   // *** type ***
 114   check(SV("__42: \"hello\"___"), SV("{:_^16m}"), input);
 115   check(SV("__42, \"hello\"___"), SV("{:_^16n}"), input);
 116
 117   for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
 118     check_exception("The format specifier should consume the input or end with a '}'",
 119                     std::basic_string_view{STR("{:") + c + STR("}")},
 120                     input);
 121   }
 122 }
 123
 124 template <class CharT, class TestFunction, class TupleOrPair>
 125 void test_escaping(TestFunction check, TupleOrPair&& input) {
 126   static_assert(std::same_as<std::remove_cvref_t<decltype(std::get<0>(input))>, CharT>);
 127   static_assert(std::same_as<std::remove_cvref_t<decltype(std::get<1>(input))>, std::basic_string<CharT>>);
 128
 129   check(SV(R"(('*', ""))"), SV("{}"), input);
 130
 131   // Char
 132   std::get<0>(input) = CharT('\t');
 133   check(SV(R"(('\t', ""))"), SV("{}"), input);
 134   std::get<0>(input) = CharT('\n');
 135   check(SV(R"(('\n', ""))"), SV("{}"), input);
 136   std::get<0>(input) = CharT('\0');
 137   check(SV(R"(('\u{0}', ""))"), SV("{}"), input);
 138
 139   // String
 140   std::get<0>(input) = CharT('*');
 141   std::get<1>(input) = SV("hellö");
 142   check(SV("('*', \"hellö\")"), SV("{}"), input);
 143 }
 144
 145 //
 146 // pair tests
 147 //
 148
 149 template <class CharT, class TestFunction, class ExceptionTest>
 150 void test_pair_int_int(TestFunction check, ExceptionTest check_exception) {
 151   test_tuple_or_pair_int_int<CharT>(check, check_exception, std::make_pair(42, 99));
 152 }
 153
 154 template <class CharT, class TestFunction, class ExceptionTest>
 155 void test_pair_int_string(TestFunction check, ExceptionTest check_exception) {
 156   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_pair(42, SV("hello")));
 157   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_pair(42, STR("hello")));
 158   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_pair(42, CSTR("hello")));
 159 }
 160
 161 //
 162 // tuple tests
 163 //
 164
 165 template <class CharT, class TestFunction, class ExceptionTest>
 166 void test_tuple_int(TestFunction check, ExceptionTest check_exception) {
 167   auto input = std::make_tuple(42);
 168
 169   check(SV("(42)"), SV("{}"), input);
 170
 171   // *** align-fill & width ***
 172   check(SV("(42)     "), SV("{:9}"), input);
 173   check(SV("(42)*****"), SV("{:*<9}"), input);
 174   check(SV("__(42)___"), SV("{:_^9}"), input);
 175   check(SV("#####(42)"), SV("{:#>9}"), input);
 176
 177   check(SV("(42)     "), SV("{:{}}"), input, 9);
 178   check(SV("(42)*****"), SV("{:*<{}}"), input, 9);
 179   check(SV("__(42)___"), SV("{:_^{}}"), input, 9);
 180   check(SV("#####(42)"), SV("{:#>{}}"), input, 9);
 181
 182   check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
 183   check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 184   check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 185
 186   // *** sign ***
 187   check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
 188   check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
 189   check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 190
 191   // *** alternate form ***
 192   check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 193
 194   // *** zero-padding ***
 195   check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 196
 197   // *** precision ***
 198   check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 199
 200   // *** locale-specific form ***
 201   check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 202
 203   // *** type ***
 204   check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 205   check(SV("__42___"), SV("{:_^7n}"), input);
 206
 207   for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
 208     check_exception("The format specifier should consume the input or end with a '}'",
 209                     std::basic_string_view{STR("{:") + c + STR("}")},
 210                     input);
 211   }
 212 }
 213
 214 template <class CharT, class TestFunction, class ExceptionTest>
 215 void test_tuple_int_string_color(TestFunction check, ExceptionTest check_exception) {
 216   const auto input = std::make_tuple(42, SV("hello"), color::red);
 217
 218   check(SV("(42, \"hello\", \"red\")"), SV("{}"), input);
 219
 220   // *** align-fill & width ***
 221   check(SV("(42, \"hello\", \"red\")     "), SV("{:25}"), input);
 222   check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<25}"), input);
 223   check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^25}"), input);
 224   check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>25}"), input);
 225
 226   check(SV("(42, \"hello\", \"red\")     "), SV("{:{}}"), input, 25);
 227   check(SV("(42, \"hello\", \"red\")*****"), SV("{:*<{}}"), input, 25);
 228   check(SV("__(42, \"hello\", \"red\")___"), SV("{:_^{}}"), input, 25);
 229   check(SV("#####(42, \"hello\", \"red\")"), SV("{:#>{}}"), input, 25);
 230
 231   check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
 232   check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 233   check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 234
 235   // *** sign ***
 236   check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
 237   check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
 238   check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 239
 240   // *** alternate form ***
 241   check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 242
 243   // *** zero-padding ***
 244   check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 245
 246   // *** precision ***
 247   check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 248
 249   // *** locale-specific form ***
 250   check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 251
 252   // *** type ***
 253   check_exception("Type m requires a pair or a tuple with two elements", SV("{:m}"), input);
 254   check(SV("__42, \"hello\", \"red\"___"), SV("{:_^23n}"), input);
 255
 256   for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
 257     check_exception("The format specifier should consume the input or end with a '}'",
 258                     std::basic_string_view{STR("{:") + c + STR("}")},
 259                     input);
 260   }
 261 }
 262
 263 template <class CharT, class TestFunction, class ExceptionTest>
 264 void test_tuple_int_int(TestFunction check, ExceptionTest check_exception) {
 265   test_tuple_or_pair_int_int<CharT>(check, check_exception, std::make_tuple(42, 99));
 266 }
 267
 268 template <class CharT, class TestFunction, class ExceptionTest>
 269 void test_tuple_int_string(TestFunction check, ExceptionTest check_exception) {
 270   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_tuple(42, SV("hello")));
 271   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_tuple(42, STR("hello")));
 272   test_tuple_or_pair_int_string<CharT>(check, check_exception, std::make_tuple(42, CSTR("hello")));
 273 }
 274
 275 //
 276 // nested tests
 277 //
 278
 279 template <class CharT, class TestFunction, class ExceptionTest, class Nested>
 280 void test_nested(TestFunction check, ExceptionTest check_exception, Nested&& input) {
 281   // [format.formatter.spec]/2
 282   //   A debug-enabled specialization of formatter additionally provides a
 283   //   public, constexpr, non-static member function set_debug_format()
 284   //   which modifies the state of the formatter to be as if the type of the
 285   //   std-format-spec parsed by the last call to parse were ?.
 286   // pair and tuple are not debug-enabled specializations to the
 287   // set_debug_format is not propagated. The paper
 288   //   P2733 Fix handling of empty specifiers in std::format
 289   // addressed this.
 290
 291   check(SV("(42, (\"hello\", \"red\"))"), SV("{}"), input);
 292
 293   // *** align-fill & width ***
 294   check(SV("(42, (\"hello\", \"red\"))     "), SV("{:27}"), input);
 295   check(SV("(42, (\"hello\", \"red\"))*****"), SV("{:*<27}"), input);
 296   check(SV("__(42, (\"hello\", \"red\"))___"), SV("{:_^27}"), input);
 297   check(SV("#####(42, (\"hello\", \"red\"))"), SV("{:#>27}"), input);
 298
 299   check(SV("(42, (\"hello\", \"red\"))     "), SV("{:{}}"), input, 27);
 300   check(SV("(42, (\"hello\", \"red\"))*****"), SV("{:*<{}}"), input, 27);
 301   check(SV("__(42, (\"hello\", \"red\"))___"), SV("{:_^{}}"), input, 27);
 302   check(SV("#####(42, (\"hello\", \"red\"))"), SV("{:#>{}}"), input, 27);
 303
 304   check_exception("The fill option contains an invalid value", SV("{:}<}"), input);
 305   check_exception("The fill option contains an invalid value", SV("{:{<}"), input);
 306   check_exception("The fill option contains an invalid value", SV("{::<}"), input);
 307
 308   // *** sign ***
 309   check_exception("The format specifier should consume the input or end with a '}'", SV("{:-}"), input);
 310   check_exception("The format specifier should consume the input or end with a '}'", SV("{:+}"), input);
 311   check_exception("The format specifier should consume the input or end with a '}'", SV("{: }"), input);
 312
 313   // *** alternate form ***
 314   check_exception("The format specifier should consume the input or end with a '}'", SV("{:#}"), input);
 315
 316   // *** zero-padding ***
 317   check_exception("The width option should not have a leading zero", SV("{:0}"), input);
 318
 319   // *** precision ***
 320   check_exception("The format specifier should consume the input or end with a '}'", SV("{:.}"), input);
 321
 322   // *** locale-specific form ***
 323   check_exception("The format specifier should consume the input or end with a '}'", SV("{:L}"), input);
 324
 325   // *** type ***
 326   check(SV("__42: (\"hello\", \"red\")___"), SV("{:_^25m}"), input);
 327   check(SV("__42, (\"hello\", \"red\")___"), SV("{:_^25n}"), input);
 328
 329   for (CharT c : SV("aAbBcdeEfFgGopPsxX?")) {
 330     check_exception("The format specifier should consume the input or end with a '}'",
 331                     std::basic_string_view{STR("{:") + c + STR("}")},
 332                     input);
 333   }
 334 }
 335
 336 template <class CharT, class TestFunction, class ExceptionTest>
 337 void run_tests(TestFunction check, ExceptionTest check_exception) {
 338   test_pair_int_int<CharT>(check, check_exception);
 339   test_pair_int_string<CharT>(check, check_exception);
 340
 341   test_tuple_int<CharT>(check, check_exception);
 342   test_tuple_int_int<CharT>(check, check_exception);
 343   test_tuple_int_string<CharT>(check, check_exception);
 344   test_tuple_int_string_color<CharT>(check, check_exception);
 345
 346   test_nested<CharT>(check, check_exception, std::make_pair(42, std::make_pair(SV("hello"), color::red)));
 347   test_nested<CharT>(check, check_exception, std::make_pair(42, std::make_tuple(SV("hello"), color::red)));
 348   test_nested<CharT>(check, check_exception, std::make_tuple(42, std::make_pair(SV("hello"), color::red)));
 349   test_nested<CharT>(check, check_exception, std::make_tuple(42, std::make_tuple(SV("hello"), color::red)));
 350
 351   test_escaping<CharT>(check, std::make_pair(CharT('*'), STR("")));
 352   test_escaping<CharT>(check, std::make_tuple(CharT('*'), STR("")));
 353
 354   // Test const ref-qualified types.
 355   // clang-format off
 356   check(SV("(42)"), SV("{}"), std::tuple<      int  >{42});
 357   check(SV("(42)"), SV("{}"), std::tuple<const int  >{42});
 358
 359   int answer = 42;
 360   check(SV("(42)"), SV("{}"), std::tuple<      int& >{answer});
 361   check(SV("(42)"), SV("{}"), std::tuple<const int& >{answer});
 362
 363   check(SV("(42)"), SV("{}"), std::tuple<      int&&>{42});
 364   check(SV("(42)"), SV("{}"), std::tuple<const int&&>{42});
 365   // clang-format on
 366 }
 367
 368 #endif // TEST_STD_UTILITIES_FORMAT_FORMAT_TUPLE_FORMAT_TESTS_H