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