1 //===- FormatVariadicTest.cpp - Unit tests for string formatting ----------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "llvm/Support/FormatAdapters.h" 11 #include "llvm/Support/FormatVariadic.h" 12 #include "gtest/gtest.h" 13 14 using namespace llvm; 15 16 TEST(FormatVariadicTest, EmptyFormatString) { 17 auto Replacements = formatv_object_base::parseFormatString(""); 18 EXPECT_EQ(0U, Replacements.size()); 19 } 20 21 TEST(FormatVariadicTest, NoReplacements) { 22 const StringRef kFormatString = "This is a test"; 23 auto Replacements = formatv_object_base::parseFormatString(kFormatString); 24 ASSERT_EQ(1U, Replacements.size()); 25 EXPECT_EQ(kFormatString, Replacements[0].Spec); 26 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type); 27 } 28 29 TEST(FormatVariadicTest, EscapedBrace) { 30 // {{ should be replaced with { 31 auto Replacements = formatv_object_base::parseFormatString("{{"); 32 ASSERT_EQ(1u, Replacements.size()); 33 EXPECT_EQ("{", Replacements[0].Spec); 34 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type); 35 36 // An even number N of braces should be replaced with N/2 braces. 37 Replacements = formatv_object_base::parseFormatString("{{{{{{"); 38 ASSERT_EQ(1u, Replacements.size()); 39 EXPECT_EQ("{{{", Replacements[0].Spec); 40 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type); 41 } 42 43 TEST(FormatVariadicTest, ValidReplacementSequence) { 44 // 1. Simple replacement - parameter index only 45 auto Replacements = formatv_object_base::parseFormatString("{0}"); 46 ASSERT_EQ(1u, Replacements.size()); 47 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 48 EXPECT_EQ(0u, Replacements[0].Index); 49 EXPECT_EQ(0u, Replacements[0].Align); 50 EXPECT_EQ("", Replacements[0].Options); 51 52 Replacements = formatv_object_base::parseFormatString("{1}"); 53 ASSERT_EQ(1u, Replacements.size()); 54 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 55 EXPECT_EQ(1u, Replacements[0].Index); 56 EXPECT_EQ(0u, Replacements[0].Align); 57 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 58 EXPECT_EQ("", Replacements[0].Options); 59 60 // 2. Parameter index with right alignment 61 Replacements = formatv_object_base::parseFormatString("{0,3}"); 62 ASSERT_EQ(1u, Replacements.size()); 63 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 64 EXPECT_EQ(0u, Replacements[0].Index); 65 EXPECT_EQ(3u, Replacements[0].Align); 66 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 67 EXPECT_EQ("", Replacements[0].Options); 68 69 // 3. And left alignment 70 Replacements = formatv_object_base::parseFormatString("{0,-3}"); 71 ASSERT_EQ(1u, Replacements.size()); 72 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 73 EXPECT_EQ(0u, Replacements[0].Index); 74 EXPECT_EQ(3u, Replacements[0].Align); 75 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where); 76 EXPECT_EQ("", Replacements[0].Options); 77 78 // 4. And center alignment 79 Replacements = formatv_object_base::parseFormatString("{0,=3}"); 80 ASSERT_EQ(1u, Replacements.size()); 81 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 82 EXPECT_EQ(0u, Replacements[0].Index); 83 EXPECT_EQ(3u, Replacements[0].Align); 84 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where); 85 EXPECT_EQ("", Replacements[0].Options); 86 87 // 4. Parameter index with option string 88 Replacements = formatv_object_base::parseFormatString("{0:foo}"); 89 ASSERT_EQ(1u, Replacements.size()); 90 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 91 EXPECT_EQ(0u, Replacements[0].Index); 92 EXPECT_EQ(0u, Replacements[0].Align); 93 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 94 EXPECT_EQ("foo", Replacements[0].Options); 95 96 // 5. Parameter index with alignment before option string 97 Replacements = formatv_object_base::parseFormatString("{0,-3:foo}"); 98 ASSERT_EQ(1u, Replacements.size()); 99 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 100 EXPECT_EQ(0u, Replacements[0].Index); 101 EXPECT_EQ(3u, Replacements[0].Align); 102 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where); 103 EXPECT_EQ("foo", Replacements[0].Options); 104 105 // 7. Parameter indices, options, and alignment can all have whitespace. 106 Replacements = formatv_object_base::parseFormatString("{ 0, -3 : foo }"); 107 ASSERT_EQ(1u, Replacements.size()); 108 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 109 EXPECT_EQ(0u, Replacements[0].Index); 110 EXPECT_EQ(3u, Replacements[0].Align); 111 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where); 112 EXPECT_EQ("foo", Replacements[0].Options); 113 114 // 8. Everything after the first option specifier is part of the style, even 115 // if it contains another option specifier. 116 Replacements = formatv_object_base::parseFormatString("{0:0:1}"); 117 ASSERT_EQ(1u, Replacements.size()); 118 EXPECT_EQ("0:0:1", Replacements[0].Spec); 119 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 120 EXPECT_EQ(0u, Replacements[0].Index); 121 EXPECT_EQ(0u, Replacements[0].Align); 122 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 123 EXPECT_EQ("0:1", Replacements[0].Options); 124 } 125 126 TEST(FormatVariadicTest, DefaultReplacementValues) { 127 // 2. If options string is missing, it defaults to empty. 128 auto Replacements = formatv_object_base::parseFormatString("{0,3}"); 129 ASSERT_EQ(1u, Replacements.size()); 130 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 131 EXPECT_EQ(0u, Replacements[0].Index); 132 EXPECT_EQ(3u, Replacements[0].Align); 133 EXPECT_EQ("", Replacements[0].Options); 134 135 // Including if the colon is present but contains no text. 136 Replacements = formatv_object_base::parseFormatString("{0,3:}"); 137 ASSERT_EQ(1u, Replacements.size()); 138 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 139 EXPECT_EQ(0u, Replacements[0].Index); 140 EXPECT_EQ(3u, Replacements[0].Align); 141 EXPECT_EQ("", Replacements[0].Options); 142 143 // 3. If alignment is missing, it defaults to 0, right, space 144 Replacements = formatv_object_base::parseFormatString("{0:foo}"); 145 ASSERT_EQ(1u, Replacements.size()); 146 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 147 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 148 EXPECT_EQ(' ', Replacements[0].Pad); 149 EXPECT_EQ(0u, Replacements[0].Index); 150 EXPECT_EQ(0u, Replacements[0].Align); 151 EXPECT_EQ("foo", Replacements[0].Options); 152 } 153 154 TEST(FormatVariadicTest, MultipleReplacements) { 155 auto Replacements = 156 formatv_object_base::parseFormatString("{0} {1:foo}-{2,-3:bar}"); 157 ASSERT_EQ(5u, Replacements.size()); 158 // {0} 159 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 160 EXPECT_EQ(0u, Replacements[0].Index); 161 EXPECT_EQ(0u, Replacements[0].Align); 162 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 163 EXPECT_EQ("", Replacements[0].Options); 164 165 // " " 166 EXPECT_EQ(ReplacementType::Literal, Replacements[1].Type); 167 EXPECT_EQ(" ", Replacements[1].Spec); 168 169 // {1:foo} - Options=foo 170 EXPECT_EQ(ReplacementType::Format, Replacements[2].Type); 171 EXPECT_EQ(1u, Replacements[2].Index); 172 EXPECT_EQ(0u, Replacements[2].Align); 173 EXPECT_EQ(AlignStyle::Right, Replacements[2].Where); 174 EXPECT_EQ("foo", Replacements[2].Options); 175 176 // "-" 177 EXPECT_EQ(ReplacementType::Literal, Replacements[3].Type); 178 EXPECT_EQ("-", Replacements[3].Spec); 179 180 // {2:bar,-3} - Options=bar, Align=-3 181 EXPECT_EQ(ReplacementType::Format, Replacements[4].Type); 182 EXPECT_EQ(2u, Replacements[4].Index); 183 EXPECT_EQ(3u, Replacements[4].Align); 184 EXPECT_EQ(AlignStyle::Left, Replacements[4].Where); 185 EXPECT_EQ("bar", Replacements[4].Options); 186 } 187 188 TEST(FormatVariadicTest, FormatNoReplacements) { 189 EXPECT_EQ("", formatv("").str()); 190 EXPECT_EQ("Test", formatv("Test").str()); 191 } 192 193 TEST(FormatVariadicTest, FormatBasicTypesOneReplacement) { 194 EXPECT_EQ("1", formatv("{0}", 1).str()); 195 EXPECT_EQ("c", formatv("{0}", 'c').str()); 196 EXPECT_EQ("-3", formatv("{0}", -3).str()); 197 EXPECT_EQ("Test", formatv("{0}", "Test").str()); 198 EXPECT_EQ("Test2", formatv("{0}", StringRef("Test2")).str()); 199 EXPECT_EQ("Test3", formatv("{0}", std::string("Test3")).str()); 200 } 201 202 TEST(FormatVariadicTest, IntegralHexFormatting) { 203 // 1. Trivial cases. Make sure hex is not the default. 204 EXPECT_EQ("0", formatv("{0}", 0).str()); 205 EXPECT_EQ("2748", formatv("{0}", 0xABC).str()); 206 EXPECT_EQ("-2748", formatv("{0}", -0xABC).str()); 207 208 // 3. various hex prefixes. 209 EXPECT_EQ("0xFF", formatv("{0:X}", 255).str()); 210 EXPECT_EQ("0xFF", formatv("{0:X+}", 255).str()); 211 EXPECT_EQ("0xff", formatv("{0:x}", 255).str()); 212 EXPECT_EQ("0xff", formatv("{0:x+}", 255).str()); 213 EXPECT_EQ("FF", formatv("{0:X-}", 255).str()); 214 EXPECT_EQ("ff", formatv("{0:x-}", 255).str()); 215 216 // 5. Precision pads left of the most significant digit but right of the 217 // prefix (if one exists). 218 EXPECT_EQ("0xFF", formatv("{0:X2}", 255).str()); 219 EXPECT_EQ("0xFF", formatv("{0:X+2}", 255).str()); 220 EXPECT_EQ("0x0ff", formatv("{0:x3}", 255).str()); 221 EXPECT_EQ("0x0ff", formatv("{0:x+3}", 255).str()); 222 EXPECT_EQ("00FF", formatv("{0:X-4}", 255).str()); 223 EXPECT_EQ("00ff", formatv("{0:x-4}", 255).str()); 224 225 // 6. Try some larger types. 226 EXPECT_EQ("0xDEADBEEFDEADBEEF", 227 formatv("{0:X16}", -2401053088876216593LL).str()); 228 EXPECT_EQ("0xFEEBDAEDFEEBDAED", 229 formatv("{0:X16}", 0xFEEBDAEDFEEBDAEDULL).str()); 230 EXPECT_EQ("0x00000000DEADBEEF", formatv("{0:X16}", 0xDEADBEEF).str()); 231 232 // 7. Padding should take into account the prefix 233 EXPECT_EQ("0xff", formatv("{0,4:x}", 255).str()); 234 EXPECT_EQ(" 0xff", formatv("{0,5:x+}", 255).str()); 235 EXPECT_EQ(" FF", formatv("{0,4:X-}", 255).str()); 236 EXPECT_EQ(" ff", formatv("{0,5:x-}", 255).str()); 237 238 // 8. Including when it's been zero-padded 239 EXPECT_EQ(" 0x0ff", formatv("{0,7:x3}", 255).str()); 240 EXPECT_EQ(" 0x00ff", formatv("{0,7:x+4}", 255).str()); 241 EXPECT_EQ(" 000FF", formatv("{0,7:X-5}", 255).str()); 242 EXPECT_EQ(" 0000ff", formatv("{0,7:x-6}", 255).str()); 243 244 // 9. Precision with default format specifier should work too 245 EXPECT_EQ(" 255", formatv("{0,7:3}", 255).str()); 246 EXPECT_EQ(" 0255", formatv("{0,7:4}", 255).str()); 247 EXPECT_EQ(" 00255", formatv("{0,7:5}", 255).str()); 248 EXPECT_EQ(" 000255", formatv("{0,7:6}", 255).str()); 249 } 250 251 TEST(FormatVariadicTest, PointerFormatting) { 252 // 1. Trivial cases. Hex is default. Default Precision is pointer width. 253 if (sizeof(void *) == 4) { 254 EXPECT_EQ("0x00000000", formatv("{0}", (void *)0).str()); 255 EXPECT_EQ("0x00000ABC", formatv("{0}", (void *)0xABC).str()); 256 } else { 257 EXPECT_EQ("0x0000000000000000", formatv("{0}", (void *)0).str()); 258 EXPECT_EQ("0x0000000000000ABC", formatv("{0}", (void *)0xABC).str()); 259 } 260 261 // 2. But we can reduce the precision explicitly. 262 EXPECT_EQ("0x0", formatv("{0:0}", (void *)0).str()); 263 EXPECT_EQ("0xABC", formatv("{0:0}", (void *)0xABC).str()); 264 EXPECT_EQ("0x0000", formatv("{0:4}", (void *)0).str()); 265 EXPECT_EQ("0x0ABC", formatv("{0:4}", (void *)0xABC).str()); 266 267 // 3. various hex prefixes. 268 EXPECT_EQ("0x0ABC", formatv("{0:X4}", (void *)0xABC).str()); 269 EXPECT_EQ("0x0abc", formatv("{0:x4}", (void *)0xABC).str()); 270 EXPECT_EQ("0ABC", formatv("{0:X-4}", (void *)0xABC).str()); 271 EXPECT_EQ("0abc", formatv("{0:x-4}", (void *)0xABC).str()); 272 } 273 274 TEST(FormatVariadicTest, IntegralNumberFormatting) { 275 // 1. Test comma grouping with default widths and precisions. 276 EXPECT_EQ("0", formatv("{0:N}", 0).str()); 277 EXPECT_EQ("10", formatv("{0:N}", 10).str()); 278 EXPECT_EQ("100", formatv("{0:N}", 100).str()); 279 EXPECT_EQ("1,000", formatv("{0:N}", 1000).str()); 280 EXPECT_EQ("1,234,567,890", formatv("{0:N}", 1234567890).str()); 281 EXPECT_EQ("-10", formatv("{0:N}", -10).str()); 282 EXPECT_EQ("-100", formatv("{0:N}", -100).str()); 283 EXPECT_EQ("-1,000", formatv("{0:N}", -1000).str()); 284 EXPECT_EQ("-1,234,567,890", formatv("{0:N}", -1234567890).str()); 285 286 // 2. If there is no comma, width and precision pad to the same absolute 287 // size. 288 EXPECT_EQ(" 1", formatv("{0,2:N}", 1).str()); 289 290 // 3. But if there is a comma or negative sign, width factors them in but 291 // precision doesn't. 292 EXPECT_EQ(" 1,000", formatv("{0,6:N}", 1000).str()); 293 EXPECT_EQ(" -1,000", formatv("{0,7:N}", -1000).str()); 294 295 // 4. Large widths all line up. 296 EXPECT_EQ(" 1,000", formatv("{0,11:N}", 1000).str()); 297 EXPECT_EQ(" -1,000", formatv("{0,11:N}", -1000).str()); 298 EXPECT_EQ(" -100,000", formatv("{0,11:N}", -100000).str()); 299 } 300 301 TEST(FormatVariadicTest, StringFormatting) { 302 const char FooArray[] = "FooArray"; 303 const char *FooPtr = "FooPtr"; 304 llvm::StringRef FooRef("FooRef"); 305 std::string FooString("FooString"); 306 // 1. Test that we can print various types of strings. 307 EXPECT_EQ(FooArray, formatv("{0}", FooArray).str()); 308 EXPECT_EQ(FooPtr, formatv("{0}", FooPtr).str()); 309 EXPECT_EQ(FooRef, formatv("{0}", FooRef).str()); 310 EXPECT_EQ(FooString, formatv("{0}", FooString).str()); 311 312 // 2. Test that the precision specifier prints the correct number of 313 // characters. 314 EXPECT_EQ("FooA", formatv("{0:4}", FooArray).str()); 315 EXPECT_EQ("FooP", formatv("{0:4}", FooPtr).str()); 316 EXPECT_EQ("FooR", formatv("{0:4}", FooRef).str()); 317 EXPECT_EQ("FooS", formatv("{0:4}", FooString).str()); 318 319 // 3. And that padding works. 320 EXPECT_EQ(" FooA", formatv("{0,6:4}", FooArray).str()); 321 EXPECT_EQ(" FooP", formatv("{0,6:4}", FooPtr).str()); 322 EXPECT_EQ(" FooR", formatv("{0,6:4}", FooRef).str()); 323 EXPECT_EQ(" FooS", formatv("{0,6:4}", FooString).str()); 324 } 325 326 TEST(FormatVariadicTest, CharFormatting) { 327 // 1. Not much to see here. Just print a char with and without padding. 328 EXPECT_EQ("C", formatv("{0}", 'C').str()); 329 EXPECT_EQ(" C", formatv("{0,3}", 'C').str()); 330 331 // 2. char is really an integral type though, where the only difference is 332 // that the "default" is to print the ASCII. So if a non-default presentation 333 // specifier exists, it should print as an integer. 334 EXPECT_EQ("37", formatv("{0:D}", (char)37).str()); 335 EXPECT_EQ(" 037", formatv("{0,5:D3}", (char)37).str()); 336 } 337 338 TEST(FormatVariadicTest, BoolTest) { 339 // 1. Default style is lowercase text (same as 't') 340 EXPECT_EQ("true", formatv("{0}", true).str()); 341 EXPECT_EQ("false", formatv("{0}", false).str()); 342 EXPECT_EQ("true", formatv("{0:t}", true).str()); 343 EXPECT_EQ("false", formatv("{0:t}", false).str()); 344 345 // 2. T - uppercase text 346 EXPECT_EQ("TRUE", formatv("{0:T}", true).str()); 347 EXPECT_EQ("FALSE", formatv("{0:T}", false).str()); 348 349 // 3. D / d - integral 350 EXPECT_EQ("1", formatv("{0:D}", true).str()); 351 EXPECT_EQ("0", formatv("{0:D}", false).str()); 352 EXPECT_EQ("1", formatv("{0:d}", true).str()); 353 EXPECT_EQ("0", formatv("{0:d}", false).str()); 354 355 // 4. Y - uppercase yes/no 356 EXPECT_EQ("YES", formatv("{0:Y}", true).str()); 357 EXPECT_EQ("NO", formatv("{0:Y}", false).str()); 358 359 // 5. y - lowercase yes/no 360 EXPECT_EQ("yes", formatv("{0:y}", true).str()); 361 EXPECT_EQ("no", formatv("{0:y}", false).str()); 362 } 363 364 TEST(FormatVariadicTest, DoubleFormatting) { 365 // Test exponents, fixed point, and percent formatting. 366 367 // 1. Signed, unsigned, and zero exponent format. 368 EXPECT_EQ("0.000000E+00", formatv("{0:E}", 0.0).str()); 369 EXPECT_EQ("-0.000000E+00", formatv("{0:E}", -0.0).str()); 370 EXPECT_EQ("1.100000E+00", formatv("{0:E}", 1.1).str()); 371 EXPECT_EQ("-1.100000E+00", formatv("{0:E}", -1.1).str()); 372 EXPECT_EQ("1.234568E+03", formatv("{0:E}", 1234.5678).str()); 373 EXPECT_EQ("-1.234568E+03", formatv("{0:E}", -1234.5678).str()); 374 EXPECT_EQ("1.234568E-03", formatv("{0:E}", .0012345678).str()); 375 EXPECT_EQ("-1.234568E-03", formatv("{0:E}", -.0012345678).str()); 376 377 // 2. With padding and precision. 378 EXPECT_EQ(" 0.000E+00", formatv("{0,11:E3}", 0.0).str()); 379 EXPECT_EQ(" -1.100E+00", formatv("{0,11:E3}", -1.1).str()); 380 EXPECT_EQ(" 1.235E+03", formatv("{0,11:E3}", 1234.5678).str()); 381 EXPECT_EQ(" -1.235E-03", formatv("{0,11:E3}", -.0012345678).str()); 382 383 // 3. Signed, unsigned, and zero fixed point format. 384 EXPECT_EQ("0.00", formatv("{0:F}", 0.0).str()); 385 EXPECT_EQ("-0.00", formatv("{0:F}", -0.0).str()); 386 EXPECT_EQ("1.10", formatv("{0:F}", 1.1).str()); 387 EXPECT_EQ("-1.10", formatv("{0:F}", -1.1).str()); 388 EXPECT_EQ("1234.57", formatv("{0:F}", 1234.5678).str()); 389 EXPECT_EQ("-1234.57", formatv("{0:F}", -1234.5678).str()); 390 EXPECT_EQ("0.00", formatv("{0:F}", .0012345678).str()); 391 EXPECT_EQ("-0.00", formatv("{0:F}", -.0012345678).str()); 392 393 // 2. With padding and precision. 394 EXPECT_EQ(" 0.000", formatv("{0,8:F3}", 0.0).str()); 395 EXPECT_EQ(" -1.100", formatv("{0,8:F3}", -1.1).str()); 396 EXPECT_EQ("1234.568", formatv("{0,8:F3}", 1234.5678).str()); 397 EXPECT_EQ(" -0.001", formatv("{0,8:F3}", -.0012345678).str()); 398 } 399 400 struct format_tuple { 401 const char *Fmt; 402 explicit format_tuple(const char *Fmt) : Fmt(Fmt) {} 403 404 template <typename... Ts> 405 auto operator()(Ts &&... Values) const 406 -> decltype(formatv(Fmt, std::forward<Ts>(Values)...)) { 407 return formatv(Fmt, std::forward<Ts>(Values)...); 408 } 409 }; 410 411 TEST(FormatVariadicTest, BigTest) { 412 using Tuple = 413 std::tuple<char, int, const char *, StringRef, std::string, double, float, 414 void *, int, double, int64_t, uint64_t, double, uint8_t>; 415 Tuple Ts[] = { 416 Tuple('a', 1, "Str", StringRef(), std::string(), 3.14159, -.17532f, 417 (void *)nullptr, 123456, 6.02E23, -908234908423, 908234908422234, 418 std::numeric_limits<double>::quiet_NaN(), 0xAB), 419 Tuple('x', 0xDDB5B, "LongerStr", "StringRef", "std::string", -2.7, 420 .08215f, (void *)nullptr, 0, 6.62E-34, -908234908423, 421 908234908422234, std::numeric_limits<double>::infinity(), 0x0)}; 422 // Test long string formatting with many edge cases combined. 423 const char *Intro = 424 "There are {{{0}} items in the tuple, and {{{1}} tuple(s) in the array."; 425 const char *Header = 426 "{0,6}|{1,8}|{2,=10}|{3,=10}|{4,=13}|{5,7}|{6,7}|{7,10}|{8," 427 "-7}|{9,10}|{10,16}|{11,17}|{12,6}|{13,4}"; 428 const char *Line = 429 "{0,6}|{1,8:X}|{2,=10}|{3,=10:5}|{4,=13}|{5,7:3}|{6,7:P2}|{7," 430 "10:X8}|{8,-7:N}|{9,10:E4}|{10,16:N}|{11,17:D}|{12,6}|{13," 431 "4:X}"; 432 433 std::string S; 434 llvm::raw_string_ostream Stream(S); 435 Stream << formatv(Intro, std::tuple_size<Tuple>::value, 436 llvm::array_lengthof(Ts)) 437 << "\n"; 438 Stream << formatv(Header, "Char", "HexInt", "Str", "Ref", "std::str", 439 "double", "float", "pointer", "comma", "exp", "bigint", 440 "bigint2", "limit", "byte") 441 << "\n"; 442 for (auto &Item : Ts) { 443 Stream << llvm::apply_tuple(format_tuple(Line), Item) << "\n"; 444 } 445 Stream.flush(); 446 const char *Expected = 447 R"foo(There are {14} items in the tuple, and {2} tuple(s) in the array. 448 Char| HexInt| Str | Ref | std::str | double| float| pointer|comma | exp| bigint| bigint2| limit|byte 449 a| 0x1| Str | | | 3.142|-17.53%|0x00000000|123,456|6.0200E+23|-908,234,908,423| 908234908422234| nan|0xAB 450 x| 0xDDB5B|LongerStr | Strin | std::string | -2.700| 8.21%|0x00000000|0 |6.6200E-34|-908,234,908,423| 908234908422234| INF| 0x0 451 )foo"; 452 453 EXPECT_EQ(Expected, S); 454 } 455 456 TEST(FormatVariadicTest, Range) { 457 std::vector<int> IntRange = {1, 1, 2, 3, 5, 8, 13}; 458 459 // 1. Simple range with default separator and element style. 460 EXPECT_EQ("1, 1, 2, 3, 5, 8, 13", 461 formatv("{0}", make_range(IntRange.begin(), IntRange.end())).str()); 462 EXPECT_EQ("1, 2, 3, 5, 8", 463 formatv("{0}", make_range(IntRange.begin() + 1, IntRange.end() - 1)) 464 .str()); 465 466 // 2. Non-default separator 467 EXPECT_EQ( 468 "1/1/2/3/5/8/13", 469 formatv("{0:$[/]}", make_range(IntRange.begin(), IntRange.end())).str()); 470 471 // 3. Default separator, non-default element style. 472 EXPECT_EQ( 473 "0x1, 0x1, 0x2, 0x3, 0x5, 0x8, 0xd", 474 formatv("{0:@[x]}", make_range(IntRange.begin(), IntRange.end())).str()); 475 476 // 4. Non-default separator and element style. 477 EXPECT_EQ( 478 "0x1 + 0x1 + 0x2 + 0x3 + 0x5 + 0x8 + 0xd", 479 formatv("{0:$[ + ]@[x]}", make_range(IntRange.begin(), IntRange.end())) 480 .str()); 481 482 // 5. Element style and/or separator using alternate delimeters to allow using 483 // delimeter characters as part of the separator. 484 EXPECT_EQ( 485 "<0x1><0x1><0x2><0x3><0x5><0x8><0xd>", 486 formatv("<{0:$[><]@(x)}>", make_range(IntRange.begin(), IntRange.end())) 487 .str()); 488 EXPECT_EQ( 489 "[0x1][0x1][0x2][0x3][0x5][0x8][0xd]", 490 formatv("[{0:$(][)@[x]}]", make_range(IntRange.begin(), IntRange.end())) 491 .str()); 492 EXPECT_EQ( 493 "(0x1)(0x1)(0x2)(0x3)(0x5)(0x8)(0xd)", 494 formatv("({0:$<)(>@<x>})", make_range(IntRange.begin(), IntRange.end())) 495 .str()); 496 497 // 5. Empty range. 498 EXPECT_EQ("", formatv("{0:$[+]@[x]}", 499 make_range(IntRange.begin(), IntRange.begin())) 500 .str()); 501 502 // 6. Empty separator and style. 503 EXPECT_EQ("11235813", 504 formatv("{0:$[]@<>}", make_range(IntRange.begin(), IntRange.end())) 505 .str()); 506 } 507 508 TEST(FormatVariadicTest, Adapter) { 509 class Negative { 510 int N; 511 512 public: 513 explicit Negative(int N) : N(N) {} 514 void format(raw_ostream &S, StringRef Options) { S << -N; } 515 }; 516 517 EXPECT_EQ("-7", formatv("{0}", Negative(7)).str()); 518 519 int N = 171; 520 521 EXPECT_EQ(" 171 ", 522 formatv("{0}", fmt_align(N, AlignStyle::Center, 7)).str()); 523 EXPECT_EQ(" 171 ", formatv("{0}", fmt_pad(N, 1, 3)).str()); 524 EXPECT_EQ("171171171171171", formatv("{0}", fmt_repeat(N, 5)).str()); 525 526 EXPECT_EQ(" ABABABABAB ", 527 formatv("{0:X-}", fmt_pad(fmt_repeat(N, 5), 1, 3)).str()); 528 EXPECT_EQ(" AB AB AB AB AB ", 529 formatv("{0,=34:X-}", fmt_repeat(fmt_pad(N, 1, 3), 5)).str()); 530 } 531 532 TEST(FormatVariadicTest, ImplicitConversions) { 533 std::string S = formatv("{0} {1}", 1, 2); 534 EXPECT_EQ("1 2", S); 535 536 SmallString<4> S2 = formatv("{0} {1}", 1, 2); 537 EXPECT_EQ("1 2", S2); 538 }