Mercurial > hg > CbC > CbC_llvm

comparison unittests/Support/FormatVariadicTest.cpp @ 120:1172e4bd9c6f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
update 4.0.0
author mir3636
date Fri, 25 Nov 2016 19:14:25 +0900
parents
children 803732b1fca8
comparison
equal deleted inserted replaced
101:34baf5011add 120:1172e4bd9c6f
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 }