807 lines · cpp
1//===- FormatVariadicTest.cpp - Unit tests for string formatting ----------===//2//3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.4// See https://llvm.org/LICENSE.txt for license information.5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/Support/FormatVariadic.h"10#include "llvm/Support/Error.h"11#include "llvm/Support/FormatAdapters.h"12#include "gmock/gmock.h"13#include "gtest/gtest.h"14 15using namespace llvm;16 17// Compile-time tests templates in the detail namespace.18namespace {19struct Format : public FormatAdapter<int> {20 Format(int N) : FormatAdapter<int>(std::move(N)) {}21 void format(raw_ostream &OS, StringRef Opt) override { OS << "Format"; }22};23 24using support::detail::uses_format_member;25using support::detail::uses_missing_provider;26 27static_assert(uses_format_member<Format>::value, "");28static_assert(uses_format_member<Format &>::value, "");29static_assert(uses_format_member<Format &&>::value, "");30static_assert(uses_format_member<const Format>::value, "");31static_assert(uses_format_member<const Format &>::value, "");32static_assert(uses_format_member<const volatile Format>::value, "");33static_assert(uses_format_member<const volatile Format &>::value, "");34 35struct NoFormat {};36static_assert(uses_missing_provider<NoFormat>::value, "");37}38 39// Helper to parse format string with no validation.40static SmallVector<ReplacementItem, 2> parseFormatString(StringRef Fmt) {41 return formatv_object_base::parseFormatString(Fmt, 0, false);42}43 44TEST(FormatVariadicTest, EmptyFormatString) {45 auto Replacements = parseFormatString("");46 EXPECT_EQ(0U, Replacements.size());47}48 49TEST(FormatVariadicTest, NoReplacements) {50 const StringRef kFormatString = "This is a test";51 auto Replacements = parseFormatString(kFormatString);52 ASSERT_EQ(1U, Replacements.size());53 EXPECT_EQ(kFormatString, Replacements[0].Spec);54 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);55}56 57TEST(FormatVariadicTest, EscapedBrace) {58 // {{ should be replaced with {59 auto Replacements = parseFormatString("{{");60 ASSERT_EQ(1u, Replacements.size());61 EXPECT_EQ("{", Replacements[0].Spec);62 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);63 64 // An even number N of braces should be replaced with N/2 braces.65 Replacements = parseFormatString("{{{{{{");66 ASSERT_EQ(1u, Replacements.size());67 EXPECT_EQ("{{{", Replacements[0].Spec);68 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);69 70 // } does not require doubling up.71 Replacements = parseFormatString("}");72 ASSERT_EQ(1u, Replacements.size());73 EXPECT_EQ("}", Replacements[0].Spec);74 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);75 76 // } does not require doubling up.77 Replacements = parseFormatString("}}}");78 ASSERT_EQ(1u, Replacements.size());79 EXPECT_EQ("}}}", Replacements[0].Spec);80 EXPECT_EQ(ReplacementType::Literal, Replacements[0].Type);81}82 83TEST(FormatVariadicTest, ValidReplacementSequence) {84 // 1. Simple replacement - parameter index only85 auto Replacements = parseFormatString("{0}");86 ASSERT_EQ(1u, Replacements.size());87 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);88 EXPECT_EQ(0u, Replacements[0].Index);89 EXPECT_EQ(0u, Replacements[0].Width);90 EXPECT_EQ("", Replacements[0].Options);91 92 Replacements = parseFormatString("{1}");93 ASSERT_EQ(1u, Replacements.size());94 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);95 EXPECT_EQ(1u, Replacements[0].Index);96 EXPECT_EQ(0u, Replacements[0].Width);97 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);98 EXPECT_EQ("", Replacements[0].Options);99 100 // 2. Parameter index with right alignment101 Replacements = parseFormatString("{0,3}");102 ASSERT_EQ(1u, Replacements.size());103 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);104 EXPECT_EQ(0u, Replacements[0].Index);105 EXPECT_EQ(3u, Replacements[0].Width);106 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);107 EXPECT_EQ("", Replacements[0].Options);108 109 // 3. And left alignment110 Replacements = parseFormatString("{0,-3}");111 ASSERT_EQ(1u, Replacements.size());112 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);113 EXPECT_EQ(0u, Replacements[0].Index);114 EXPECT_EQ(3u, Replacements[0].Width);115 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);116 EXPECT_EQ("", Replacements[0].Options);117 118 // 4. And center alignment119 Replacements = parseFormatString("{0,=3}");120 ASSERT_EQ(1u, Replacements.size());121 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);122 EXPECT_EQ(0u, Replacements[0].Index);123 EXPECT_EQ(3u, Replacements[0].Width);124 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);125 EXPECT_EQ("", Replacements[0].Options);126 127 // 4. Parameter index with option string128 Replacements = parseFormatString("{0:foo}");129 ASSERT_EQ(1u, Replacements.size());130 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);131 EXPECT_EQ(0u, Replacements[0].Index);132 EXPECT_EQ(0u, Replacements[0].Width);133 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);134 EXPECT_EQ("foo", Replacements[0].Options);135 136 // 5. Parameter index with alignment before option string137 Replacements = parseFormatString("{0,-3:foo}");138 ASSERT_EQ(1u, Replacements.size());139 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);140 EXPECT_EQ(0u, Replacements[0].Index);141 EXPECT_EQ(3u, Replacements[0].Width);142 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);143 EXPECT_EQ("foo", Replacements[0].Options);144 145 // 7. Parameter indices, options, and alignment can all have whitespace.146 Replacements = parseFormatString("{ 0, -3 : foo }");147 ASSERT_EQ(1u, Replacements.size());148 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);149 EXPECT_EQ(0u, Replacements[0].Index);150 EXPECT_EQ(3u, Replacements[0].Width);151 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);152 EXPECT_EQ(" foo ", Replacements[0].Options);153 154 // 8. Everything after the first option specifier is part of the style, even155 // if it contains another option specifier.156 Replacements = parseFormatString("{0:0:1}");157 ASSERT_EQ(1u, Replacements.size());158 EXPECT_EQ("0:0:1", Replacements[0].Spec);159 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);160 EXPECT_EQ(0u, Replacements[0].Index);161 EXPECT_EQ(0u, Replacements[0].Width);162 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);163 EXPECT_EQ("0:1", Replacements[0].Options);164 165 // 9. Custom padding character166 Replacements = parseFormatString("{0,p+4:foo}");167 ASSERT_EQ(1u, Replacements.size());168 EXPECT_EQ("0,p+4:foo", Replacements[0].Spec);169 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);170 EXPECT_EQ(0u, Replacements[0].Index);171 EXPECT_EQ(4u, Replacements[0].Width);172 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);173 EXPECT_EQ('p', Replacements[0].Pad);174 EXPECT_EQ("foo", Replacements[0].Options);175 176 // Format string special characters are allowed as padding character177 Replacements = parseFormatString("{0,-+4:foo}");178 ASSERT_EQ(1u, Replacements.size());179 EXPECT_EQ("0,-+4:foo", Replacements[0].Spec);180 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);181 EXPECT_EQ(0u, Replacements[0].Index);182 EXPECT_EQ(4u, Replacements[0].Width);183 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);184 EXPECT_EQ('-', Replacements[0].Pad);185 EXPECT_EQ("foo", Replacements[0].Options);186 187 Replacements = parseFormatString("{0,+-4:foo}");188 ASSERT_EQ(1u, Replacements.size());189 EXPECT_EQ("0,+-4:foo", Replacements[0].Spec);190 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);191 EXPECT_EQ(0u, Replacements[0].Index);192 EXPECT_EQ(4u, Replacements[0].Width);193 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);194 EXPECT_EQ('+', Replacements[0].Pad);195 EXPECT_EQ("foo", Replacements[0].Options);196 197 Replacements = parseFormatString("{0,==4:foo}");198 ASSERT_EQ(1u, Replacements.size());199 EXPECT_EQ("0,==4:foo", Replacements[0].Spec);200 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);201 EXPECT_EQ(0u, Replacements[0].Index);202 EXPECT_EQ(4u, Replacements[0].Width);203 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);204 EXPECT_EQ('=', Replacements[0].Pad);205 EXPECT_EQ("foo", Replacements[0].Options);206 207 Replacements = parseFormatString("{0,:=4:foo}");208 ASSERT_EQ(1u, Replacements.size());209 EXPECT_EQ("0,:=4:foo", Replacements[0].Spec);210 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);211 EXPECT_EQ(0u, Replacements[0].Index);212 EXPECT_EQ(4u, Replacements[0].Width);213 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);214 EXPECT_EQ(':', Replacements[0].Pad);215 EXPECT_EQ("foo", Replacements[0].Options);216}217 218TEST(FormatVariadicTest, DefaultReplacementValues) {219 // 2. If options string is missing, it defaults to empty.220 auto Replacements = parseFormatString("{0,3}");221 ASSERT_EQ(1u, Replacements.size());222 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);223 EXPECT_EQ(0u, Replacements[0].Index);224 EXPECT_EQ(3u, Replacements[0].Width);225 EXPECT_EQ("", Replacements[0].Options);226 227 // Including if the colon is present but contains no text.228 Replacements = parseFormatString("{0,3:}");229 ASSERT_EQ(1u, Replacements.size());230 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);231 EXPECT_EQ(0u, Replacements[0].Index);232 EXPECT_EQ(3u, Replacements[0].Width);233 EXPECT_EQ("", Replacements[0].Options);234 235 // 3. If alignment is missing, it defaults to 0, right, space236 Replacements = parseFormatString("{0:foo}");237 ASSERT_EQ(1u, Replacements.size());238 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);239 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);240 EXPECT_EQ(' ', Replacements[0].Pad);241 EXPECT_EQ(0u, Replacements[0].Index);242 EXPECT_EQ(0u, Replacements[0].Width);243 EXPECT_EQ("foo", Replacements[0].Options);244}245 246TEST(FormatVariadicTest, MultipleReplacements) {247 auto Replacements = parseFormatString("{0} {1:foo}-{2,-3:bar}");248 ASSERT_EQ(5u, Replacements.size());249 // {0}250 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);251 EXPECT_EQ(0u, Replacements[0].Index);252 EXPECT_EQ(0u, Replacements[0].Width);253 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);254 EXPECT_EQ("", Replacements[0].Options);255 256 // " "257 EXPECT_EQ(ReplacementType::Literal, Replacements[1].Type);258 EXPECT_EQ(" ", Replacements[1].Spec);259 260 // {1:foo} - Options=foo261 EXPECT_EQ(ReplacementType::Format, Replacements[2].Type);262 EXPECT_EQ(1u, Replacements[2].Index);263 EXPECT_EQ(0u, Replacements[2].Width);264 EXPECT_EQ(AlignStyle::Right, Replacements[2].Where);265 EXPECT_EQ("foo", Replacements[2].Options);266 267 // "-"268 EXPECT_EQ(ReplacementType::Literal, Replacements[3].Type);269 EXPECT_EQ("-", Replacements[3].Spec);270 271 // {2,-3:bar} - Options=bar, Align=-3272 EXPECT_EQ(ReplacementType::Format, Replacements[4].Type);273 EXPECT_EQ(2u, Replacements[4].Index);274 EXPECT_EQ(3u, Replacements[4].Width);275 EXPECT_EQ(AlignStyle::Left, Replacements[4].Where);276 EXPECT_EQ("bar", Replacements[4].Options);277}278 279TEST(FormatVariadicTest, AutomaticIndices) {280 auto Replacements = parseFormatString("{}");281 ASSERT_EQ(1u, Replacements.size());282 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);283 EXPECT_EQ(0u, Replacements[0].Index);284 285 Replacements = parseFormatString("{}bar{}");286 ASSERT_EQ(3u, Replacements.size());287 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);288 EXPECT_EQ(0u, Replacements[0].Index);289 EXPECT_EQ(ReplacementType::Literal, Replacements[1].Type);290 EXPECT_EQ("bar", Replacements[1].Spec);291 EXPECT_EQ(ReplacementType::Format, Replacements[2].Type);292 EXPECT_EQ(1u, Replacements[2].Index);293 294 Replacements = parseFormatString("{}{}");295 ASSERT_EQ(2u, Replacements.size());296 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);297 EXPECT_EQ(0u, Replacements[0].Index);298 EXPECT_EQ(ReplacementType::Format, Replacements[1].Type);299 EXPECT_EQ(1u, Replacements[1].Index);300 301 Replacements = parseFormatString("{}{:foo}{,-3:bar}");302 ASSERT_EQ(3u, Replacements.size());303 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);304 EXPECT_EQ(0u, Replacements[0].Index);305 EXPECT_EQ(0u, Replacements[0].Width);306 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);307 EXPECT_EQ("", Replacements[0].Options);308 309 // {:foo} - Options=foo310 EXPECT_EQ(ReplacementType::Format, Replacements[1].Type);311 EXPECT_EQ(1u, Replacements[1].Index);312 EXPECT_EQ(0u, Replacements[1].Width);313 EXPECT_EQ(AlignStyle::Right, Replacements[1].Where);314 EXPECT_EQ("foo", Replacements[1].Options);315 316 // {,-3:bar} - Options=bar, Align=-3317 EXPECT_EQ(ReplacementType::Format, Replacements[2].Type);318 EXPECT_EQ(2u, Replacements[2].Index);319 EXPECT_EQ(3u, Replacements[2].Width);320 EXPECT_EQ(AlignStyle::Left, Replacements[2].Where);321 EXPECT_EQ("bar", Replacements[2].Options);322}323 324TEST(FormatVariadicTest, FormatNoReplacements) {325 EXPECT_EQ("", formatv("").str());326 EXPECT_EQ("Test", formatv("Test").str());327}328 329TEST(FormatVariadicTest, FormatBasicTypesOneReplacement) {330 EXPECT_EQ("1", formatv("{0}", 1).str());331 EXPECT_EQ("c", formatv("{0}", 'c').str());332 EXPECT_EQ("-3", formatv("{0}", -3).str());333 EXPECT_EQ("Test", formatv("{0}", "Test").str());334 EXPECT_EQ("Test2", formatv("{0}", StringRef("Test2")).str());335 EXPECT_EQ("Test3", formatv("{0}", std::string("Test3")).str());336}337 338TEST(FormatVariadicTest, FormatAutomaticIndices) {339 EXPECT_EQ("1", formatv("{}", 1).str());340 EXPECT_EQ("c1", formatv("{}{}", 'c', 1).str());341 EXPECT_EQ("c-1rrr-0xFF", formatv("{}-{,r-4}-{:X}", 'c', 1, 255).str());342}343 344TEST(FormatVariadicTest, IntegralHexFormatting) {345 // 1. Trivial cases. Make sure hex is not the default.346 EXPECT_EQ("0", formatv("{0}", 0).str());347 EXPECT_EQ("2748", formatv("{0}", 0xABC).str());348 EXPECT_EQ("-2748", formatv("{0}", -0xABC).str());349 350 // 3. various hex prefixes.351 EXPECT_EQ("0xFF", formatv("{0:X}", 255).str());352 EXPECT_EQ("0xFF", formatv("{0:X+}", 255).str());353 EXPECT_EQ("0xff", formatv("{0:x}", 255).str());354 EXPECT_EQ("0xff", formatv("{0:x+}", 255).str());355 EXPECT_EQ("FF", formatv("{0:X-}", 255).str());356 EXPECT_EQ("ff", formatv("{0:x-}", 255).str());357 358 // 5. Precision pads left of the most significant digit but right of the359 // prefix (if one exists).360 EXPECT_EQ("0xFF", formatv("{0:X2}", 255).str());361 EXPECT_EQ("0xFF", formatv("{0:X+2}", 255).str());362 EXPECT_EQ("0x0ff", formatv("{0:x3}", 255).str());363 EXPECT_EQ("0x0ff", formatv("{0:x+3}", 255).str());364 EXPECT_EQ("00FF", formatv("{0:X-4}", 255).str());365 EXPECT_EQ("00ff", formatv("{0:x-4}", 255).str());366 367 // 6. Try some larger types.368 EXPECT_EQ("0xDEADBEEFDEADBEEF",369 formatv("{0:X16}", -2401053088876216593LL).str());370 EXPECT_EQ("0xFEEBDAEDFEEBDAED",371 formatv("{0:X16}", 0xFEEBDAEDFEEBDAEDULL).str());372 EXPECT_EQ("0x00000000DEADBEEF", formatv("{0:X16}", 0xDEADBEEF).str());373 374 // 7. Padding should take into account the prefix375 EXPECT_EQ("0xff", formatv("{0,4:x}", 255).str());376 EXPECT_EQ(" 0xff", formatv("{0,5:x+}", 255).str());377 EXPECT_EQ(" FF", formatv("{0,4:X-}", 255).str());378 EXPECT_EQ(" ff", formatv("{0,5:x-}", 255).str());379 380 // 8. Including when it's been zero-padded381 EXPECT_EQ(" 0x0ff", formatv("{0,7:x3}", 255).str());382 EXPECT_EQ(" 0x00ff", formatv("{0,7:x+4}", 255).str());383 EXPECT_EQ(" 000FF", formatv("{0,7:X-5}", 255).str());384 EXPECT_EQ(" 0000ff", formatv("{0,7:x-6}", 255).str());385 386 // 9. Precision with default format specifier should work too387 EXPECT_EQ(" 255", formatv("{0,7:3}", 255).str());388 EXPECT_EQ(" 0255", formatv("{0,7:4}", 255).str());389 EXPECT_EQ(" 00255", formatv("{0,7:5}", 255).str());390 EXPECT_EQ(" 000255", formatv("{0,7:6}", 255).str());391}392 393TEST(FormatVariadicTest, PointerFormatting) {394 // 1. Trivial cases. Hex is default. Default Precision is pointer width.395 if (sizeof(void *) == 4) {396 EXPECT_EQ("0x00000000", formatv("{0}", (void *)0).str());397 EXPECT_EQ("0x00000ABC", formatv("{0}", (void *)0xABC).str());398 } else {399 EXPECT_EQ("0x0000000000000000", formatv("{0}", (void *)0).str());400 EXPECT_EQ("0x0000000000000ABC", formatv("{0}", (void *)0xABC).str());401 }402 403 // 2. But we can reduce the precision explicitly.404 EXPECT_EQ("0x0", formatv("{0:0}", (void *)0).str());405 EXPECT_EQ("0xABC", formatv("{0:0}", (void *)0xABC).str());406 EXPECT_EQ("0x0000", formatv("{0:4}", (void *)0).str());407 EXPECT_EQ("0x0ABC", formatv("{0:4}", (void *)0xABC).str());408 409 // 3. various hex prefixes.410 EXPECT_EQ("0x0ABC", formatv("{0:X4}", (void *)0xABC).str());411 EXPECT_EQ("0x0abc", formatv("{0:x4}", (void *)0xABC).str());412 EXPECT_EQ("0ABC", formatv("{0:X-4}", (void *)0xABC).str());413 EXPECT_EQ("0abc", formatv("{0:x-4}", (void *)0xABC).str());414}415 416TEST(FormatVariadicTest, IntegralNumberFormatting) {417 // 1. Test comma grouping with default widths and precisions.418 EXPECT_EQ("0", formatv("{0:N}", 0).str());419 EXPECT_EQ("10", formatv("{0:N}", 10).str());420 EXPECT_EQ("100", formatv("{0:N}", 100).str());421 EXPECT_EQ("1,000", formatv("{0:N}", 1000).str());422 EXPECT_EQ("1,234,567,890", formatv("{0:N}", 1234567890).str());423 EXPECT_EQ("-10", formatv("{0:N}", -10).str());424 EXPECT_EQ("-100", formatv("{0:N}", -100).str());425 EXPECT_EQ("-1,000", formatv("{0:N}", -1000).str());426 EXPECT_EQ("-1,234,567,890", formatv("{0:N}", -1234567890).str());427 428 // 2. If there is no comma, width and precision pad to the same absolute429 // size.430 EXPECT_EQ(" 1", formatv("{0,2:N}", 1).str());431 432 // 3. But if there is a comma or negative sign, width factors them in but433 // precision doesn't.434 EXPECT_EQ(" 1,000", formatv("{0,6:N}", 1000).str());435 EXPECT_EQ(" -1,000", formatv("{0,7:N}", -1000).str());436 437 // 4. Large widths all line up.438 EXPECT_EQ(" 1,000", formatv("{0,11:N}", 1000).str());439 EXPECT_EQ(" -1,000", formatv("{0,11:N}", -1000).str());440 EXPECT_EQ(" -100,000", formatv("{0,11:N}", -100000).str());441}442 443TEST(FormatVariadicTest, StringFormatting) {444 const char FooArray[] = "FooArray";445 const char *FooPtr = "FooPtr";446 llvm::StringRef FooRef("FooRef");447 constexpr StringLiteral FooLiteral("FooLiteral");448 std::string FooString("FooString");449 // 1. Test that we can print various types of strings.450 EXPECT_EQ(FooArray, formatv("{0}", FooArray).str());451 EXPECT_EQ(FooPtr, formatv("{0}", FooPtr).str());452 EXPECT_EQ(FooRef, formatv("{0}", FooRef).str());453 EXPECT_EQ(FooLiteral, formatv("{0}", FooLiteral).str());454 EXPECT_EQ(FooString, formatv("{0}", FooString).str());455 456 // 2. Test that the precision specifier prints the correct number of457 // characters.458 EXPECT_EQ("FooA", formatv("{0:4}", FooArray).str());459 EXPECT_EQ("FooP", formatv("{0:4}", FooPtr).str());460 EXPECT_EQ("FooR", formatv("{0:4}", FooRef).str());461 EXPECT_EQ("FooS", formatv("{0:4}", FooString).str());462 463 // 3. And that padding works.464 EXPECT_EQ(" FooA", formatv("{0,6:4}", FooArray).str());465 EXPECT_EQ(" FooP", formatv("{0,6:4}", FooPtr).str());466 EXPECT_EQ(" FooR", formatv("{0,6:4}", FooRef).str());467 EXPECT_EQ(" FooS", formatv("{0,6:4}", FooString).str());468}469 470TEST(FormatVariadicTest, CharFormatting) {471 // 1. Not much to see here. Just print a char with and without padding.472 EXPECT_EQ("C", formatv("{0}", 'C').str());473 EXPECT_EQ(" C", formatv("{0,3}", 'C').str());474 475 // 2. char is really an integral type though, where the only difference is476 // that the "default" is to print the ASCII. So if a non-default presentation477 // specifier exists, it should print as an integer.478 EXPECT_EQ("37", formatv("{0:D}", (char)37).str());479 EXPECT_EQ(" 037", formatv("{0,5:D3}", (char)37).str());480}481 482TEST(FormatVariadicTest, BoolTest) {483 // 1. Default style is lowercase text (same as 't')484 EXPECT_EQ("true", formatv("{0}", true).str());485 EXPECT_EQ("false", formatv("{0}", false).str());486 EXPECT_EQ("true", formatv("{0:t}", true).str());487 EXPECT_EQ("false", formatv("{0:t}", false).str());488 489 // 2. T - uppercase text490 EXPECT_EQ("TRUE", formatv("{0:T}", true).str());491 EXPECT_EQ("FALSE", formatv("{0:T}", false).str());492 493 // 3. D / d - integral494 EXPECT_EQ("1", formatv("{0:D}", true).str());495 EXPECT_EQ("0", formatv("{0:D}", false).str());496 EXPECT_EQ("1", formatv("{0:d}", true).str());497 EXPECT_EQ("0", formatv("{0:d}", false).str());498 499 // 4. Y - uppercase yes/no500 EXPECT_EQ("YES", formatv("{0:Y}", true).str());501 EXPECT_EQ("NO", formatv("{0:Y}", false).str());502 503 // 5. y - lowercase yes/no504 EXPECT_EQ("yes", formatv("{0:y}", true).str());505 EXPECT_EQ("no", formatv("{0:y}", false).str());506}507 508TEST(FormatVariadicTest, DoubleFormatting) {509 // Test exponents, fixed point, and percent formatting.510 511 // 1. Signed, unsigned, and zero exponent format.512 EXPECT_EQ("0.000000E+00", formatv("{0:E}", 0.0).str());513 EXPECT_EQ("-0.000000E+00", formatv("{0:E}", -0.0).str());514 EXPECT_EQ("1.100000E+00", formatv("{0:E}", 1.1).str());515 EXPECT_EQ("-1.100000E+00", formatv("{0:E}", -1.1).str());516 EXPECT_EQ("1.234568E+03", formatv("{0:E}", 1234.5678).str());517 EXPECT_EQ("-1.234568E+03", formatv("{0:E}", -1234.5678).str());518 EXPECT_EQ("1.234568E-03", formatv("{0:E}", .0012345678).str());519 EXPECT_EQ("-1.234568E-03", formatv("{0:E}", -.0012345678).str());520 521 // 2. With padding and precision.522 EXPECT_EQ(" 0.000E+00", formatv("{0,11:E3}", 0.0).str());523 EXPECT_EQ(" -1.100E+00", formatv("{0,11:E3}", -1.1).str());524 EXPECT_EQ(" 1.235E+03", formatv("{0,11:E3}", 1234.5678).str());525 EXPECT_EQ(" -1.235E-03", formatv("{0,11:E3}", -.0012345678).str());526 527 // 3. Signed, unsigned, and zero fixed point format.528 EXPECT_EQ("0.00", formatv("{0:F}", 0.0).str());529 EXPECT_EQ("-0.00", formatv("{0:F}", -0.0).str());530 EXPECT_EQ("1.10", formatv("{0:F}", 1.1).str());531 EXPECT_EQ("-1.10", formatv("{0:F}", -1.1).str());532 EXPECT_EQ("1234.57", formatv("{0:F}", 1234.5678).str());533 EXPECT_EQ("-1234.57", formatv("{0:F}", -1234.5678).str());534 EXPECT_EQ("0.00", formatv("{0:F}", .0012345678).str());535 EXPECT_EQ("-0.00", formatv("{0:F}", -.0012345678).str());536 537 // 2. With padding and precision.538 EXPECT_EQ(" 0.000", formatv("{0,8:F3}", 0.0).str());539 EXPECT_EQ(" -1.100", formatv("{0,8:F3}", -1.1).str());540 EXPECT_EQ("1234.568", formatv("{0,8:F3}", 1234.5678).str());541 EXPECT_EQ(" -0.001", formatv("{0,8:F3}", -.0012345678).str());542}543 544TEST(FormatVariadicTest, CustomPaddingCharacter) {545 // 1. Padding with custom character546 EXPECT_EQ("==123", formatv("{0,=+5}", 123).str());547 EXPECT_EQ("=123=", formatv("{0,==5}", 123).str());548 EXPECT_EQ("123==", formatv("{0,=-5}", 123).str());549 550 // 2. Combined with zero padding551 EXPECT_EQ("=00123=", formatv("{0,==7:5}", 123).str());552}553 554struct format_tuple {555 const char *Fmt;556 explicit format_tuple(const char *Fmt) : Fmt(Fmt) {}557 558 template <typename... Ts> auto operator()(Ts &&... Values) const {559 return formatv(Fmt, std::forward<Ts>(Values)...);560 }561};562 563TEST(FormatVariadicTest, BigTest) {564 using Tuple =565 std::tuple<char, int, const char *, StringRef, std::string, double, float,566 void *, int, double, int64_t, uint64_t, double, uint8_t>;567 Tuple Ts[] = {568 Tuple('a', 1, "Str", StringRef(), std::string(), 3.14159, -.17532f,569 (void *)nullptr, 123456, 6.02E23, -908234908423, 908234908422234,570 std::numeric_limits<double>::quiet_NaN(), 0xAB),571 Tuple('x', 0xDDB5B, "LongerStr", "StringRef", "std::string", -2.7,572 .08215f, (void *)nullptr, 0, 6.62E-34, -908234908423,573 908234908422234, std::numeric_limits<double>::infinity(), 0x0)};574 // Test long string formatting with many edge cases combined.575 const char *Intro =576 "There are {{{0}} items in the tuple, and {{{1}} tuple(s) in the array.";577 const char *Header =578 "{0,6}|{1,8}|{2,=10}|{3,=10}|{4,=13}|{5,7}|{6,7}|{7,10}|{8,"579 "-7}|{9,10}|{10,16}|{11,17}|{12,6}|{13,4}";580 const char *Line =581 "{0,6}|{1,8:X}|{2,=10}|{3,=10:5}|{4,=13}|{5,7:3}|{6,7:P2}|{7,"582 "10:X8}|{8,-7:N}|{9,10:E4}|{10,16:N}|{11,17:D}|{12,6}|{13,"583 "4:X}";584 585 std::string S;586 llvm::raw_string_ostream Stream(S);587 Stream << formatv(Intro, std::tuple_size<Tuple>::value, std::size(Ts))588 << "\n";589 Stream << formatv(Header, "Char", "HexInt", "Str", "Ref", "std::str",590 "double", "float", "pointer", "comma", "exp", "bigint",591 "bigint2", "limit", "byte")592 << "\n";593 for (auto &Item : Ts) {594 Stream << std::apply(format_tuple(Line), Item) << "\n";595 }596 const char *Expected =597 R"foo(There are {14} items in the tuple, and {2} tuple(s) in the array.598 Char| HexInt| Str | Ref | std::str | double| float| pointer|comma | exp| bigint| bigint2| limit|byte599 a| 0x1| Str | | | 3.142|-17.53%|0x00000000|123,456|6.0200E+23|-908,234,908,423| 908234908422234| nan|0xAB600 x| 0xDDB5B|LongerStr | Strin | std::string | -2.700| 8.21%|0x00000000|0 |6.6200E-34|-908,234,908,423| 908234908422234| INF| 0x0601)foo";602 603 EXPECT_EQ(Expected, S);604}605 606TEST(FormatVariadicTest, Range) {607 std::vector<int> IntRange = {1, 1, 2, 3, 5, 8, 13};608 609 // 1. Simple range with default separator and element style.610 EXPECT_EQ("1, 1, 2, 3, 5, 8, 13",611 formatv("{0}", make_range(IntRange.begin(), IntRange.end())).str());612 EXPECT_EQ("1, 2, 3, 5, 8",613 formatv("{0}", make_range(IntRange.begin() + 1, IntRange.end() - 1))614 .str());615 616 // 2. Non-default separator617 EXPECT_EQ(618 "1/1/2/3/5/8/13",619 formatv("{0:$[/]}", make_range(IntRange.begin(), IntRange.end())).str());620 621 // 3. Default separator, non-default element style.622 EXPECT_EQ(623 "0x1, 0x1, 0x2, 0x3, 0x5, 0x8, 0xd",624 formatv("{0:@[x]}", make_range(IntRange.begin(), IntRange.end())).str());625 626 // 4. Non-default separator and element style.627 EXPECT_EQ(628 "0x1 + 0x1 + 0x2 + 0x3 + 0x5 + 0x8 + 0xd",629 formatv("{0:$[ + ]@[x]}", make_range(IntRange.begin(), IntRange.end()))630 .str());631 632 // 5. Element style and/or separator using alternate delimeters to allow using633 // delimeter characters as part of the separator.634 EXPECT_EQ(635 "<0x1><0x1><0x2><0x3><0x5><0x8><0xd>",636 formatv("<{0:$[><]@(x)}>", make_range(IntRange.begin(), IntRange.end()))637 .str());638 EXPECT_EQ(639 "[0x1][0x1][0x2][0x3][0x5][0x8][0xd]",640 formatv("[{0:$(][)@[x]}]", make_range(IntRange.begin(), IntRange.end()))641 .str());642 EXPECT_EQ(643 "(0x1)(0x1)(0x2)(0x3)(0x5)(0x8)(0xd)",644 formatv("({0:$<)(>@<x>})", make_range(IntRange.begin(), IntRange.end()))645 .str());646 647 // 5. Empty range.648 EXPECT_EQ("", formatv("{0:$[+]@[x]}",649 make_range(IntRange.begin(), IntRange.begin()))650 .str());651 652 // 6. Empty separator and style.653 EXPECT_EQ("11235813",654 formatv("{0:$[]@<>}", make_range(IntRange.begin(), IntRange.end()))655 .str());656}657 658TEST(FormatVariadicTest, Adapter) {659 class Negative : public FormatAdapter<int> {660 public:661 explicit Negative(int N) : FormatAdapter<int>(std::move(N)) {}662 void format(raw_ostream &S, StringRef Options) override { S << -Item; }663 };664 665 EXPECT_EQ("-7", formatv("{0}", Negative(7)).str());666 667 int N = 171;668 669 EXPECT_EQ(" 171 ",670 formatv("{0}", fmt_align(N, AlignStyle::Center, 7)).str());671 EXPECT_EQ("--171--",672 formatv("{0}", fmt_align(N, AlignStyle::Center, 7, '-')).str());673 EXPECT_EQ(" 171 ", formatv("{0}", fmt_pad(N, 1, 3)).str());674 EXPECT_EQ("171171171171171", formatv("{0}", fmt_repeat(N, 5)).str());675 676 EXPECT_EQ(" ABABABABAB ",677 formatv("{0:X-}", fmt_pad(fmt_repeat(N, 5), 1, 3)).str());678 EXPECT_EQ(" AB AB AB AB AB ",679 formatv("{0,=34:X-}", fmt_repeat(fmt_pad(N, 1, 3), 5)).str());680}681 682TEST(FormatVariadicTest, MoveConstructor) {683 auto fmt = formatv("{0} {1}", 1, 2);684 auto fmt2 = std::move(fmt);685 std::string S = std::string(fmt2);686 EXPECT_EQ("1 2", S);687}688TEST(FormatVariadicTest, ImplicitConversions) {689 std::string S = std::string(formatv("{0} {1}", 1, 2));690 EXPECT_EQ("1 2", S);691 692 SmallString<4> S2 = formatv("{0} {1}", 1, 2);693 EXPECT_EQ("1 2", S2);694}695 696TEST(FormatVariadicTest, FormatAdapter) {697 EXPECT_EQ("Format", formatv("{0}", Format(1)).str());698 699 Format var(1);700 EXPECT_EQ("Format", formatv("{0}", var).str());701 EXPECT_EQ("Format", formatv("{0}", std::move(var)).str());702 703 // Not supposed to compile704 // const Format cvar(1);705 // EXPECT_EQ("Format", formatv("{0}", cvar).str());706}707 708TEST(FormatVariadicTest, FormatFormatvObject) {709 EXPECT_EQ("Format", formatv("F{0}t", formatv("o{0}a", "rm")).str());710 EXPECT_EQ("[ ! ]", formatv("[{0,+5}]", formatv("{0,-2}", "!")).str());711}712 713namespace {714struct Recorder {715 int Copied = 0, Moved = 0;716 Recorder() = default;717 Recorder(const Recorder &Copy) : Copied(1 + Copy.Copied), Moved(Copy.Moved) {}718 Recorder(const Recorder &&Move)719 : Copied(Move.Copied), Moved(1 + Move.Moved) {}720};721} // namespace722namespace llvm {723template <> struct format_provider<Recorder> {724 static void format(const Recorder &R, raw_ostream &OS, StringRef style) {725 OS << R.Copied << "C " << R.Moved << "M";726 }727};728} // namespace729 730TEST(FormatVariadicTest, CopiesAndMoves) {731 Recorder R;732 EXPECT_EQ("0C 0M", formatv("{0}", R).str());733 EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str());734 EXPECT_EQ("0C 3M", formatv("{0}", Recorder()).str());735 EXPECT_EQ(0, R.Copied);736 EXPECT_EQ(0, R.Moved);737}738 739namespace adl {740struct X {};741raw_ostream &operator<<(raw_ostream &OS, const X &) { return OS << "X"; }742} // namespace adl743TEST(FormatVariadicTest, FormatStreamable) {744 adl::X X;745 EXPECT_EQ("X", formatv("{0}", X).str());746}747 748TEST(FormatVariadicTest, FormatError) {749 auto E1 = make_error<StringError>("X", inconvertibleErrorCode());750 EXPECT_EQ("X", formatv("{0}", E1).str());751 EXPECT_TRUE(E1.isA<StringError>()); // not consumed752 EXPECT_EQ("X", formatv("{0}", fmt_consume(std::move(E1))).str());753 EXPECT_FALSE(E1.isA<StringError>()); // consumed754}755 756TEST(FormatVariadicTest, FormatFilterRange) {757 std::vector<int> Vec{0, 1, 2};758 auto Range = map_range(Vec, [](int V) { return V + 1; });759 EXPECT_EQ("1, 2, 3", formatv("{0}", Range).str());760}761 762TEST(FormatVariadicTest, Validate) {763#ifndef NDEBUG764#if GTEST_HAS_DEATH_TEST765 // If asserts are enabled, verify that invalid formatv calls cause assertions.766 EXPECT_DEATH(formatv("{0}", 1, 2).str(), "Expected 1 Args, but got 2");767 EXPECT_DEATH(formatv("{0} {2}", 1, 2, 3).str(),768 "Replacement field indices cannot have holes");769 EXPECT_DEATH(formatv("{}{1}", 0, 1).str(),770 "Cannot mix automatic and explicit indices");771 EXPECT_DEATH(formatv("{}{0}{}", 0, 1).str(),772 "Cannot mix automatic and explicit indices");773#else // GTEST_HAS_DEATH_TEST774 GTEST_SKIP() << "No support for EXPECT_DEATH";775#endif // GTEST_HAS_DEATH_TEST776#else // NDEBUG777 // If asserts are disabled, verify that validation is disabled.778 EXPECT_EQ(formatv("{0}", 1, 2).str(), "1");779 EXPECT_EQ(formatv("{0} {2}", 1, 2, 3).str(), "1 3");780 EXPECT_EQ(formatv("{}{1}", 0, 1).str(), "01");781 EXPECT_EQ(formatv("{}{0}{}", 0, 1).str(), "001");782#endif // NDEBUG783}784 785namespace {786 787enum class Base { First };788 789class IntegerValuesRange final790 : public indexed_accessor_range<IntegerValuesRange, Base, int, int *, int> {791public:792 using indexed_accessor_range<IntegerValuesRange, Base, int, int *,793 int>::indexed_accessor_range;794 795 static int dereference(const Base &, ptrdiff_t Index) {796 return static_cast<int>(Index);797 }798};799 800TEST(FormatVariadicTest, FormatRangeNonRef) {801 IntegerValuesRange Range(Base(), 0, 3);802 EXPECT_EQ("0, 1, 2",803 formatv("{0}", make_range(Range.begin(), Range.end())).str());804}805 806} // namespace807