1
2 #include <cstdarg>
3 #include <cstdint>
4 #include <cstdio>
5 #include <string>
6
7 #include "gmock/gmock.h"
8 #include "gtest/gtest.h"
9 #include "absl/strings/str_format.h"
10 #include "absl/strings/string_view.h"
11
12 namespace absl {
13 ABSL_NAMESPACE_BEGIN
14 namespace {
15 using str_format_internal::FormatArgImpl;
16
17 using FormatEntryPointTest = ::testing::Test;
18
TEST_F(FormatEntryPointTest,Format)19 TEST_F(FormatEntryPointTest, Format) {
20 std::string sink;
21 EXPECT_TRUE(Format(&sink, "A format %d", 123));
22 EXPECT_EQ("A format 123", sink);
23 sink.clear();
24
25 ParsedFormat<'d'> pc("A format %d");
26 EXPECT_TRUE(Format(&sink, pc, 123));
27 EXPECT_EQ("A format 123", sink);
28 }
TEST_F(FormatEntryPointTest,UntypedFormat)29 TEST_F(FormatEntryPointTest, UntypedFormat) {
30 constexpr const char* formats[] = {
31 "",
32 "a",
33 "%80d",
34 #if !defined(_MSC_VER) && !defined(__ANDROID__) && !defined(__native_client__)
35 // MSVC, NaCL and Android don't support positional syntax.
36 "complicated multipart %% %1$d format %1$0999d",
37 #endif // _MSC_VER
38 };
39 for (const char* fmt : formats) {
40 std::string actual;
41 int i = 123;
42 FormatArgImpl arg_123(i);
43 absl::Span<const FormatArgImpl> args(&arg_123, 1);
44 UntypedFormatSpec format(fmt);
45
46 EXPECT_TRUE(FormatUntyped(&actual, format, args));
47 char buf[4096]{};
48 snprintf(buf, sizeof(buf), fmt, 123);
49 EXPECT_EQ(
50 str_format_internal::FormatPack(
51 str_format_internal::UntypedFormatSpecImpl::Extract(format), args),
52 buf);
53 EXPECT_EQ(actual, buf);
54 }
55 // The internal version works with a preparsed format.
56 ParsedFormat<'d'> pc("A format %d");
57 int i = 345;
58 FormatArg arg(i);
59 std::string out;
60 EXPECT_TRUE(str_format_internal::FormatUntyped(
61 &out, str_format_internal::UntypedFormatSpecImpl(&pc), {&arg, 1}));
62 EXPECT_EQ("A format 345", out);
63 }
64
TEST_F(FormatEntryPointTest,StringFormat)65 TEST_F(FormatEntryPointTest, StringFormat) {
66 EXPECT_EQ("123", StrFormat("%d", 123));
67 constexpr absl::string_view view("=%d=", 4);
68 EXPECT_EQ("=123=", StrFormat(view, 123));
69 }
70
TEST_F(FormatEntryPointTest,AppendFormat)71 TEST_F(FormatEntryPointTest, AppendFormat) {
72 std::string s;
73 std::string& r = StrAppendFormat(&s, "%d", 123);
74 EXPECT_EQ(&s, &r); // should be same object
75 EXPECT_EQ("123", r);
76 }
77
TEST_F(FormatEntryPointTest,AppendFormatFail)78 TEST_F(FormatEntryPointTest, AppendFormatFail) {
79 std::string s = "orig";
80
81 UntypedFormatSpec format(" more %d");
82 FormatArgImpl arg("not an int");
83
84 EXPECT_EQ("orig",
85 str_format_internal::AppendPack(
86 &s, str_format_internal::UntypedFormatSpecImpl::Extract(format),
87 {&arg, 1}));
88 }
89
90
TEST_F(FormatEntryPointTest,ManyArgs)91 TEST_F(FormatEntryPointTest, ManyArgs) {
92 EXPECT_EQ("24", StrFormat("%24$d", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
93 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24));
94 EXPECT_EQ("60", StrFormat("%60$d", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
95 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
96 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,
97 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
98 53, 54, 55, 56, 57, 58, 59, 60));
99 }
100
TEST_F(FormatEntryPointTest,Preparsed)101 TEST_F(FormatEntryPointTest, Preparsed) {
102 ParsedFormat<'d'> pc("%d");
103 EXPECT_EQ("123", StrFormat(pc, 123));
104 // rvalue ok?
105 EXPECT_EQ("123", StrFormat(ParsedFormat<'d'>("%d"), 123));
106 constexpr absl::string_view view("=%d=", 4);
107 EXPECT_EQ("=123=", StrFormat(ParsedFormat<'d'>(view), 123));
108 }
109
TEST_F(FormatEntryPointTest,FormatCountCapture)110 TEST_F(FormatEntryPointTest, FormatCountCapture) {
111 int n = 0;
112 EXPECT_EQ("", StrFormat("%n", FormatCountCapture(&n)));
113 EXPECT_EQ(0, n);
114 EXPECT_EQ("123", StrFormat("%d%n", 123, FormatCountCapture(&n)));
115 EXPECT_EQ(3, n);
116 }
117
TEST_F(FormatEntryPointTest,FormatCountCaptureWrongType)118 TEST_F(FormatEntryPointTest, FormatCountCaptureWrongType) {
119 // Should reject int*.
120 int n = 0;
121 UntypedFormatSpec format("%d%n");
122 int i = 123, *ip = &n;
123 FormatArgImpl args[2] = {FormatArgImpl(i), FormatArgImpl(ip)};
124
125 EXPECT_EQ("", str_format_internal::FormatPack(
126 str_format_internal::UntypedFormatSpecImpl::Extract(format),
127 absl::MakeSpan(args)));
128 }
129
TEST_F(FormatEntryPointTest,FormatCountCaptureMultiple)130 TEST_F(FormatEntryPointTest, FormatCountCaptureMultiple) {
131 int n1 = 0;
132 int n2 = 0;
133 EXPECT_EQ(" 1 2",
134 StrFormat("%5d%n%10d%n", 1, FormatCountCapture(&n1), 2,
135 FormatCountCapture(&n2)));
136 EXPECT_EQ(5, n1);
137 EXPECT_EQ(15, n2);
138 }
139
TEST_F(FormatEntryPointTest,FormatCountCaptureExample)140 TEST_F(FormatEntryPointTest, FormatCountCaptureExample) {
141 int n;
142 std::string s;
143 StrAppendFormat(&s, "%s: %n%s\n", "(1,1)", FormatCountCapture(&n), "(1,2)");
144 StrAppendFormat(&s, "%*s%s\n", n, "", "(2,2)");
145 EXPECT_EQ(7, n);
146 EXPECT_EQ(
147 "(1,1): (1,2)\n"
148 " (2,2)\n",
149 s);
150 }
151
TEST_F(FormatEntryPointTest,Stream)152 TEST_F(FormatEntryPointTest, Stream) {
153 const std::string formats[] = {
154 "",
155 "a",
156 "%80d",
157 "%d %u %c %s %f %g",
158 #if !defined(_MSC_VER) && !defined(__ANDROID__) && !defined(__native_client__)
159 // MSVC, NaCL and Android don't support positional syntax.
160 "complicated multipart %% %1$d format %1$080d",
161 #endif // _MSC_VER
162 };
163 std::string buf(4096, '\0');
164 for (const auto& fmt : formats) {
165 const auto parsed =
166 ParsedFormat<'d', 'u', 'c', 's', 'f', 'g'>::NewAllowIgnored(fmt);
167 std::ostringstream oss;
168 oss << StreamFormat(*parsed, 123, 3, 49, "multistreaming!!!", 1.01, 1.01);
169 int fmt_result = snprintf(&*buf.begin(), buf.size(), fmt.c_str(), //
170 123, 3, 49, "multistreaming!!!", 1.01, 1.01);
171 ASSERT_TRUE(oss) << fmt;
172 ASSERT_TRUE(fmt_result >= 0 && static_cast<size_t>(fmt_result) < buf.size())
173 << fmt_result;
174 EXPECT_EQ(buf.c_str(), oss.str());
175 }
176 }
177
TEST_F(FormatEntryPointTest,StreamOk)178 TEST_F(FormatEntryPointTest, StreamOk) {
179 std::ostringstream oss;
180 oss << StreamFormat("hello %d", 123);
181 EXPECT_EQ("hello 123", oss.str());
182 EXPECT_TRUE(oss.good());
183 }
184
TEST_F(FormatEntryPointTest,StreamFail)185 TEST_F(FormatEntryPointTest, StreamFail) {
186 std::ostringstream oss;
187 UntypedFormatSpec format("hello %d");
188 FormatArgImpl arg("non-numeric");
189 oss << str_format_internal::Streamable(
190 str_format_internal::UntypedFormatSpecImpl::Extract(format), {&arg, 1});
191 EXPECT_EQ("hello ", oss.str()); // partial write
192 EXPECT_TRUE(oss.fail());
193 }
194
WithSnprintf(const char * fmt,...)195 std::string WithSnprintf(const char* fmt, ...) {
196 std::string buf;
197 buf.resize(128);
198 va_list va;
199 va_start(va, fmt);
200 int r = vsnprintf(&*buf.begin(), buf.size(), fmt, va);
201 va_end(va);
202 EXPECT_GE(r, 0);
203 EXPECT_LT(r, buf.size());
204 buf.resize(r);
205 return buf;
206 }
207
TEST_F(FormatEntryPointTest,FloatPrecisionArg)208 TEST_F(FormatEntryPointTest, FloatPrecisionArg) {
209 // Test that positional parameters for width and precision
210 // are indexed to precede the value.
211 // Also sanity check the same formats against snprintf.
212 EXPECT_EQ("0.1", StrFormat("%.1f", 0.1));
213 EXPECT_EQ("0.1", WithSnprintf("%.1f", 0.1));
214 EXPECT_EQ(" 0.1", StrFormat("%*.1f", 5, 0.1));
215 EXPECT_EQ(" 0.1", WithSnprintf("%*.1f", 5, 0.1));
216 EXPECT_EQ("0.1", StrFormat("%.*f", 1, 0.1));
217 EXPECT_EQ("0.1", WithSnprintf("%.*f", 1, 0.1));
218 EXPECT_EQ(" 0.1", StrFormat("%*.*f", 5, 1, 0.1));
219 EXPECT_EQ(" 0.1", WithSnprintf("%*.*f", 5, 1, 0.1));
220 }
221 namespace streamed_test {
222 struct X {};
operator <<(std::ostream & os,const X &)223 std::ostream& operator<<(std::ostream& os, const X&) {
224 return os << "X";
225 }
226 } // streamed_test
227
TEST_F(FormatEntryPointTest,FormatStreamed)228 TEST_F(FormatEntryPointTest, FormatStreamed) {
229 EXPECT_EQ("123", StrFormat("%s", FormatStreamed(123)));
230 EXPECT_EQ(" 123", StrFormat("%5s", FormatStreamed(123)));
231 EXPECT_EQ("123 ", StrFormat("%-5s", FormatStreamed(123)));
232 EXPECT_EQ("X", StrFormat("%s", FormatStreamed(streamed_test::X())));
233 EXPECT_EQ("123", StrFormat("%s", FormatStreamed(StreamFormat("%d", 123))));
234 }
235
236 // Helper class that creates a temporary file and exposes a FILE* to it.
237 // It will close the file on destruction.
238 class TempFile {
239 public:
TempFile()240 TempFile() : file_(std::tmpfile()) {}
~TempFile()241 ~TempFile() { std::fclose(file_); }
242
file() const243 std::FILE* file() const { return file_; }
244
245 // Read the file into a std::string.
ReadFile()246 std::string ReadFile() {
247 std::fseek(file_, 0, SEEK_END);
248 int size = std::ftell(file_);
249 EXPECT_GT(size, 0);
250 std::rewind(file_);
251 std::string str(2 * size, ' ');
252 int read_bytes = std::fread(&str[0], 1, str.size(), file_);
253 EXPECT_EQ(read_bytes, size);
254 str.resize(read_bytes);
255 EXPECT_TRUE(std::feof(file_));
256 return str;
257 }
258
259 private:
260 std::FILE* file_;
261 };
262
TEST_F(FormatEntryPointTest,FPrintF)263 TEST_F(FormatEntryPointTest, FPrintF) {
264 TempFile tmp;
265 int result =
266 FPrintF(tmp.file(), "STRING: %s NUMBER: %010d", std::string("ABC"), -19);
267 EXPECT_EQ(result, 30);
268 EXPECT_EQ(tmp.ReadFile(), "STRING: ABC NUMBER: -000000019");
269 }
270
TEST_F(FormatEntryPointTest,FPrintFError)271 TEST_F(FormatEntryPointTest, FPrintFError) {
272 errno = 0;
273 int result = FPrintF(stdin, "ABC");
274 EXPECT_LT(result, 0);
275 EXPECT_EQ(errno, EBADF);
276 }
277
278 #ifdef __GLIBC__
TEST_F(FormatEntryPointTest,FprintfTooLarge)279 TEST_F(FormatEntryPointTest, FprintfTooLarge) {
280 std::FILE* f = std::fopen("/dev/null", "w");
281 int width = 2000000000;
282 errno = 0;
283 int result = FPrintF(f, "%*d %*d", width, 0, width, 0);
284 EXPECT_LT(result, 0);
285 EXPECT_EQ(errno, EFBIG);
286 std::fclose(f);
287 }
288
TEST_F(FormatEntryPointTest,PrintF)289 TEST_F(FormatEntryPointTest, PrintF) {
290 int stdout_tmp = dup(STDOUT_FILENO);
291
292 TempFile tmp;
293 std::fflush(stdout);
294 dup2(fileno(tmp.file()), STDOUT_FILENO);
295
296 int result = PrintF("STRING: %s NUMBER: %010d", std::string("ABC"), -19);
297
298 std::fflush(stdout);
299 dup2(stdout_tmp, STDOUT_FILENO);
300 close(stdout_tmp);
301
302 EXPECT_EQ(result, 30);
303 EXPECT_EQ(tmp.ReadFile(), "STRING: ABC NUMBER: -000000019");
304 }
305 #endif // __GLIBC__
306
TEST_F(FormatEntryPointTest,SNPrintF)307 TEST_F(FormatEntryPointTest, SNPrintF) {
308 char buffer[16];
309 int result =
310 SNPrintF(buffer, sizeof(buffer), "STRING: %s", std::string("ABC"));
311 EXPECT_EQ(result, 11);
312 EXPECT_EQ(std::string(buffer), "STRING: ABC");
313
314 result = SNPrintF(buffer, sizeof(buffer), "NUMBER: %d", 123456);
315 EXPECT_EQ(result, 14);
316 EXPECT_EQ(std::string(buffer), "NUMBER: 123456");
317
318 result = SNPrintF(buffer, sizeof(buffer), "NUMBER: %d", 1234567);
319 EXPECT_EQ(result, 15);
320 EXPECT_EQ(std::string(buffer), "NUMBER: 1234567");
321
322 result = SNPrintF(buffer, sizeof(buffer), "NUMBER: %d", 12345678);
323 EXPECT_EQ(result, 16);
324 EXPECT_EQ(std::string(buffer), "NUMBER: 1234567");
325
326 result = SNPrintF(buffer, sizeof(buffer), "NUMBER: %d", 123456789);
327 EXPECT_EQ(result, 17);
328 EXPECT_EQ(std::string(buffer), "NUMBER: 1234567");
329
330 result = SNPrintF(nullptr, 0, "Just checking the %s of the output.", "size");
331 EXPECT_EQ(result, 37);
332 }
333
TEST(StrFormat,BehavesAsDocumented)334 TEST(StrFormat, BehavesAsDocumented) {
335 std::string s = absl::StrFormat("%s, %d!", "Hello", 123);
336 EXPECT_EQ("Hello, 123!", s);
337 // The format of a replacement is
338 // '%'[position][flags][width['.'precision]][length_modifier][format]
339 EXPECT_EQ(absl::StrFormat("%1$+3.2Lf", 1.1), "+1.10");
340 // Text conversion:
341 // "c" - Character. Eg: 'a' -> "A", 20 -> " "
342 EXPECT_EQ(StrFormat("%c", 'a'), "a");
343 EXPECT_EQ(StrFormat("%c", 0x20), " ");
344 // Formats char and integral types: int, long, uint64_t, etc.
345 EXPECT_EQ(StrFormat("%c", int{'a'}), "a");
346 EXPECT_EQ(StrFormat("%c", long{'a'}), "a"); // NOLINT
347 EXPECT_EQ(StrFormat("%c", uint64_t{'a'}), "a");
348 // "s" - std::string Eg: "C" -> "C", std::string("C++") -> "C++"
349 // Formats std::string, char*, string_view, and Cord.
350 EXPECT_EQ(StrFormat("%s", "C"), "C");
351 EXPECT_EQ(StrFormat("%s", std::string("C++")), "C++");
352 EXPECT_EQ(StrFormat("%s", string_view("view")), "view");
353 // Integral Conversion
354 // These format integral types: char, int, long, uint64_t, etc.
355 EXPECT_EQ(StrFormat("%d", char{10}), "10");
356 EXPECT_EQ(StrFormat("%d", int{10}), "10");
357 EXPECT_EQ(StrFormat("%d", long{10}), "10"); // NOLINT
358 EXPECT_EQ(StrFormat("%d", uint64_t{10}), "10");
359 // d,i - signed decimal Eg: -10 -> "-10"
360 EXPECT_EQ(StrFormat("%d", -10), "-10");
361 EXPECT_EQ(StrFormat("%i", -10), "-10");
362 // o - octal Eg: 10 -> "12"
363 EXPECT_EQ(StrFormat("%o", 10), "12");
364 // u - unsigned decimal Eg: 10 -> "10"
365 EXPECT_EQ(StrFormat("%u", 10), "10");
366 // x/X - lower,upper case hex Eg: 10 -> "a"/"A"
367 EXPECT_EQ(StrFormat("%x", 10), "a");
368 EXPECT_EQ(StrFormat("%X", 10), "A");
369 // Floating-point, with upper/lower-case output.
370 // These format floating points types: float, double, long double, etc.
371 EXPECT_EQ(StrFormat("%.1f", float{1}), "1.0");
372 EXPECT_EQ(StrFormat("%.1f", double{1}), "1.0");
373 const long double long_double = 1.0;
374 EXPECT_EQ(StrFormat("%.1f", long_double), "1.0");
375 // These also format integral types: char, int, long, uint64_t, etc.:
376 EXPECT_EQ(StrFormat("%.1f", char{1}), "1.0");
377 EXPECT_EQ(StrFormat("%.1f", int{1}), "1.0");
378 EXPECT_EQ(StrFormat("%.1f", long{1}), "1.0"); // NOLINT
379 EXPECT_EQ(StrFormat("%.1f", uint64_t{1}), "1.0");
380 // f/F - decimal. Eg: 123456789 -> "123456789.000000"
381 EXPECT_EQ(StrFormat("%f", 123456789), "123456789.000000");
382 EXPECT_EQ(StrFormat("%F", 123456789), "123456789.000000");
383 // e/E - exponentiated Eg: .01 -> "1.00000e-2"/"1.00000E-2"
384 EXPECT_EQ(StrFormat("%e", .01), "1.000000e-02");
385 EXPECT_EQ(StrFormat("%E", .01), "1.000000E-02");
386 // g/G - exponentiate to fit Eg: .01 -> "0.01", 1e10 ->"1e+10"/"1E+10"
387 EXPECT_EQ(StrFormat("%g", .01), "0.01");
388 EXPECT_EQ(StrFormat("%g", 1e10), "1e+10");
389 EXPECT_EQ(StrFormat("%G", 1e10), "1E+10");
390 // a/A - lower,upper case hex Eg: -3.0 -> "-0x1.8p+1"/"-0X1.8P+1"
391
392 // On Android platform <=21, there is a regression in hexfloat formatting.
393 #if !defined(__ANDROID_API__) || __ANDROID_API__ > 21
394 EXPECT_EQ(StrFormat("%.1a", -3.0), "-0x1.8p+1"); // .1 to fix MSVC output
395 EXPECT_EQ(StrFormat("%.1A", -3.0), "-0X1.8P+1"); // .1 to fix MSVC output
396 #endif
397
398 // Other conversion
399 int64_t value = 0x7ffdeb4;
400 auto ptr_value = static_cast<uintptr_t>(value);
401 const int& something = *reinterpret_cast<const int*>(ptr_value);
402 EXPECT_EQ(StrFormat("%p", &something), StrFormat("0x%x", ptr_value));
403
404 // Output widths are supported, with optional flags.
405 EXPECT_EQ(StrFormat("%3d", 1), " 1");
406 EXPECT_EQ(StrFormat("%3d", 123456), "123456");
407 EXPECT_EQ(StrFormat("%06.2f", 1.234), "001.23");
408 EXPECT_EQ(StrFormat("%+d", 1), "+1");
409 EXPECT_EQ(StrFormat("% d", 1), " 1");
410 EXPECT_EQ(StrFormat("%-4d", -1), "-1 ");
411 EXPECT_EQ(StrFormat("%#o", 10), "012");
412 EXPECT_EQ(StrFormat("%#x", 15), "0xf");
413 EXPECT_EQ(StrFormat("%04d", 8), "0008");
414 // Posix positional substitution.
415 EXPECT_EQ(absl::StrFormat("%2$s, %3$s, %1$s!", "vici", "veni", "vidi"),
416 "veni, vidi, vici!");
417 // Length modifiers are ignored.
418 EXPECT_EQ(StrFormat("%hhd", int{1}), "1");
419 EXPECT_EQ(StrFormat("%hd", int{1}), "1");
420 EXPECT_EQ(StrFormat("%ld", int{1}), "1");
421 EXPECT_EQ(StrFormat("%lld", int{1}), "1");
422 EXPECT_EQ(StrFormat("%Ld", int{1}), "1");
423 EXPECT_EQ(StrFormat("%jd", int{1}), "1");
424 EXPECT_EQ(StrFormat("%zd", int{1}), "1");
425 EXPECT_EQ(StrFormat("%td", int{1}), "1");
426 EXPECT_EQ(StrFormat("%qd", int{1}), "1");
427 }
428
429 using str_format_internal::ExtendedParsedFormat;
430 using str_format_internal::ParsedFormatBase;
431
432 struct SummarizeConsumer {
433 std::string* out;
SummarizeConsumerabsl::__anon6129bffe0111::SummarizeConsumer434 explicit SummarizeConsumer(std::string* out) : out(out) {}
435
Appendabsl::__anon6129bffe0111::SummarizeConsumer436 bool Append(string_view s) {
437 *out += "[" + std::string(s) + "]";
438 return true;
439 }
440
ConvertOneabsl::__anon6129bffe0111::SummarizeConsumer441 bool ConvertOne(const str_format_internal::UnboundConversion& conv,
442 string_view s) {
443 *out += "{";
444 *out += std::string(s);
445 *out += ":";
446 *out += std::to_string(conv.arg_position) + "$";
447 if (conv.width.is_from_arg()) {
448 *out += std::to_string(conv.width.get_from_arg()) + "$*";
449 }
450 if (conv.precision.is_from_arg()) {
451 *out += "." + std::to_string(conv.precision.get_from_arg()) + "$*";
452 }
453 *out += FormatConversionCharToChar(conv.conv);
454 *out += "}";
455 return true;
456 }
457 };
458
SummarizeParsedFormat(const ParsedFormatBase & pc)459 std::string SummarizeParsedFormat(const ParsedFormatBase& pc) {
460 std::string out;
461 if (!pc.ProcessFormat(SummarizeConsumer(&out))) out += "!";
462 return out;
463 }
464
465 using ParsedFormatTest = ::testing::Test;
466
TEST_F(ParsedFormatTest,SimpleChecked)467 TEST_F(ParsedFormatTest, SimpleChecked) {
468 EXPECT_EQ("[ABC]{d:1$d}[DEF]",
469 SummarizeParsedFormat(ParsedFormat<'d'>("ABC%dDEF")));
470 EXPECT_EQ("{s:1$s}[FFF]{d:2$d}[ZZZ]{f:3$f}",
471 SummarizeParsedFormat(ParsedFormat<'s', 'd', 'f'>("%sFFF%dZZZ%f")));
472 EXPECT_EQ("{s:1$s}[ ]{.*d:3$.2$*d}",
473 SummarizeParsedFormat(ParsedFormat<'s', '*', 'd'>("%s %.*d")));
474 }
475
TEST_F(ParsedFormatTest,SimpleUncheckedCorrect)476 TEST_F(ParsedFormatTest, SimpleUncheckedCorrect) {
477 auto f = ParsedFormat<'d'>::New("ABC%dDEF");
478 ASSERT_TRUE(f);
479 EXPECT_EQ("[ABC]{d:1$d}[DEF]", SummarizeParsedFormat(*f));
480
481 std::string format = "%sFFF%dZZZ%f";
482 auto f2 = ParsedFormat<'s', 'd', 'f'>::New(format);
483
484 ASSERT_TRUE(f2);
485 EXPECT_EQ("{s:1$s}[FFF]{d:2$d}[ZZZ]{f:3$f}", SummarizeParsedFormat(*f2));
486
487 f2 = ParsedFormat<'s', 'd', 'f'>::New("%s %d %f");
488
489 ASSERT_TRUE(f2);
490 EXPECT_EQ("{s:1$s}[ ]{d:2$d}[ ]{f:3$f}", SummarizeParsedFormat(*f2));
491
492 auto star = ParsedFormat<'*', 'd'>::New("%*d");
493 ASSERT_TRUE(star);
494 EXPECT_EQ("{*d:2$1$*d}", SummarizeParsedFormat(*star));
495
496 auto dollar = ParsedFormat<'d', 's'>::New("%2$s %1$d");
497 ASSERT_TRUE(dollar);
498 EXPECT_EQ("{2$s:2$s}[ ]{1$d:1$d}", SummarizeParsedFormat(*dollar));
499 // with reuse
500 dollar = ParsedFormat<'d', 's'>::New("%2$s %1$d %1$d");
501 ASSERT_TRUE(dollar);
502 EXPECT_EQ("{2$s:2$s}[ ]{1$d:1$d}[ ]{1$d:1$d}",
503 SummarizeParsedFormat(*dollar));
504 }
505
TEST_F(ParsedFormatTest,SimpleUncheckedIgnoredArgs)506 TEST_F(ParsedFormatTest, SimpleUncheckedIgnoredArgs) {
507 EXPECT_FALSE((ParsedFormat<'d', 's'>::New("ABC")));
508 EXPECT_FALSE((ParsedFormat<'d', 's'>::New("%dABC")));
509 EXPECT_FALSE((ParsedFormat<'d', 's'>::New("ABC%2$s")));
510 auto f = ParsedFormat<'d', 's'>::NewAllowIgnored("ABC");
511 ASSERT_TRUE(f);
512 EXPECT_EQ("[ABC]", SummarizeParsedFormat(*f));
513 f = ParsedFormat<'d', 's'>::NewAllowIgnored("%dABC");
514 ASSERT_TRUE(f);
515 EXPECT_EQ("{d:1$d}[ABC]", SummarizeParsedFormat(*f));
516 f = ParsedFormat<'d', 's'>::NewAllowIgnored("ABC%2$s");
517 ASSERT_TRUE(f);
518 EXPECT_EQ("[ABC]{2$s:2$s}", SummarizeParsedFormat(*f));
519 }
520
TEST_F(ParsedFormatTest,SimpleUncheckedUnsupported)521 TEST_F(ParsedFormatTest, SimpleUncheckedUnsupported) {
522 EXPECT_FALSE(ParsedFormat<'d'>::New("%1$d %1$x"));
523 EXPECT_FALSE(ParsedFormat<'x'>::New("%1$d %1$x"));
524 }
525
TEST_F(ParsedFormatTest,SimpleUncheckedIncorrect)526 TEST_F(ParsedFormatTest, SimpleUncheckedIncorrect) {
527 EXPECT_FALSE(ParsedFormat<'d'>::New(""));
528
529 EXPECT_FALSE(ParsedFormat<'d'>::New("ABC%dDEF%d"));
530
531 std::string format = "%sFFF%dZZZ%f";
532 EXPECT_FALSE((ParsedFormat<'s', 'd', 'g'>::New(format)));
533 }
534
535 using str_format_internal::Conv;
536
TEST_F(ParsedFormatTest,UncheckedCorrect)537 TEST_F(ParsedFormatTest, UncheckedCorrect) {
538 auto f = ExtendedParsedFormat<Conv::d>::New("ABC%dDEF");
539 ASSERT_TRUE(f);
540 EXPECT_EQ("[ABC]{d:1$d}[DEF]", SummarizeParsedFormat(*f));
541
542 std::string format = "%sFFF%dZZZ%f";
543 auto f2 =
544 ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(format);
545
546 ASSERT_TRUE(f2);
547 EXPECT_EQ("{s:1$s}[FFF]{d:2$d}[ZZZ]{f:3$f}", SummarizeParsedFormat(*f2));
548
549 f2 = ExtendedParsedFormat<Conv::string, Conv::d, Conv::floating>::New(
550 "%s %d %f");
551
552 ASSERT_TRUE(f2);
553 EXPECT_EQ("{s:1$s}[ ]{d:2$d}[ ]{f:3$f}", SummarizeParsedFormat(*f2));
554
555 auto star = ExtendedParsedFormat<Conv::star, Conv::d>::New("%*d");
556 ASSERT_TRUE(star);
557 EXPECT_EQ("{*d:2$1$*d}", SummarizeParsedFormat(*star));
558
559 auto dollar = ExtendedParsedFormat<Conv::d, Conv::s>::New("%2$s %1$d");
560 ASSERT_TRUE(dollar);
561 EXPECT_EQ("{2$s:2$s}[ ]{1$d:1$d}", SummarizeParsedFormat(*dollar));
562 // with reuse
563 dollar = ExtendedParsedFormat<Conv::d, Conv::s>::New("%2$s %1$d %1$d");
564 ASSERT_TRUE(dollar);
565 EXPECT_EQ("{2$s:2$s}[ ]{1$d:1$d}[ ]{1$d:1$d}",
566 SummarizeParsedFormat(*dollar));
567 }
568
TEST_F(ParsedFormatTest,UncheckedIgnoredArgs)569 TEST_F(ParsedFormatTest, UncheckedIgnoredArgs) {
570 EXPECT_FALSE((ExtendedParsedFormat<Conv::d, Conv::s>::New("ABC")));
571 EXPECT_FALSE((ExtendedParsedFormat<Conv::d, Conv::s>::New("%dABC")));
572 EXPECT_FALSE((ExtendedParsedFormat<Conv::d, Conv::s>::New("ABC%2$s")));
573 auto f = ExtendedParsedFormat<Conv::d, Conv::s>::NewAllowIgnored("ABC");
574 ASSERT_TRUE(f);
575 EXPECT_EQ("[ABC]", SummarizeParsedFormat(*f));
576 f = ExtendedParsedFormat<Conv::d, Conv::s>::NewAllowIgnored("%dABC");
577 ASSERT_TRUE(f);
578 EXPECT_EQ("{d:1$d}[ABC]", SummarizeParsedFormat(*f));
579 f = ExtendedParsedFormat<Conv::d, Conv::s>::NewAllowIgnored("ABC%2$s");
580 ASSERT_TRUE(f);
581 EXPECT_EQ("[ABC]{2$s:2$s}", SummarizeParsedFormat(*f));
582 }
583
TEST_F(ParsedFormatTest,UncheckedMultipleTypes)584 TEST_F(ParsedFormatTest, UncheckedMultipleTypes) {
585 auto dx = ExtendedParsedFormat<Conv::d | Conv::x>::New("%1$d %1$x");
586 EXPECT_TRUE(dx);
587 EXPECT_EQ("{1$d:1$d}[ ]{1$x:1$x}", SummarizeParsedFormat(*dx));
588
589 dx = ExtendedParsedFormat<Conv::d | Conv::x>::New("%1$d");
590 EXPECT_TRUE(dx);
591 EXPECT_EQ("{1$d:1$d}", SummarizeParsedFormat(*dx));
592 }
593
TEST_F(ParsedFormatTest,UncheckedIncorrect)594 TEST_F(ParsedFormatTest, UncheckedIncorrect) {
595 EXPECT_FALSE(ExtendedParsedFormat<Conv::d>::New(""));
596
597 EXPECT_FALSE(ExtendedParsedFormat<Conv::d>::New("ABC%dDEF%d"));
598
599 std::string format = "%sFFF%dZZZ%f";
600 EXPECT_FALSE((ExtendedParsedFormat<Conv::s, Conv::d, Conv::g>::New(format)));
601 }
602
TEST_F(ParsedFormatTest,RegressionMixPositional)603 TEST_F(ParsedFormatTest, RegressionMixPositional) {
604 EXPECT_FALSE((ExtendedParsedFormat<Conv::d, Conv::o>::New("%1$d %o")));
605 }
606
607 using FormatWrapperTest = ::testing::Test;
608
609 // Plain wrapper for StrFormat.
610 template <typename... Args>
WrappedFormat(const absl::FormatSpec<Args...> & format,const Args &...args)611 std::string WrappedFormat(const absl::FormatSpec<Args...>& format,
612 const Args&... args) {
613 return StrFormat(format, args...);
614 }
615
TEST_F(FormatWrapperTest,ConstexprStringFormat)616 TEST_F(FormatWrapperTest, ConstexprStringFormat) {
617 EXPECT_EQ(WrappedFormat("%s there", "hello"), "hello there");
618 }
619
TEST_F(FormatWrapperTest,ParsedFormat)620 TEST_F(FormatWrapperTest, ParsedFormat) {
621 ParsedFormat<'s'> format("%s there");
622 EXPECT_EQ(WrappedFormat(format, "hello"), "hello there");
623 }
624
625 } // namespace
626 ABSL_NAMESPACE_END
627 } // namespace absl
628
629 // Some codegen thunks that we can use to easily dump the generated assembly for
630 // different StrFormat calls.
631
CodegenAbslStrFormatInt(int i)632 std::string CodegenAbslStrFormatInt(int i) { // NOLINT
633 return absl::StrFormat("%d", i);
634 }
635
CodegenAbslStrFormatIntStringInt64(int i,const std::string & s,int64_t i64)636 std::string CodegenAbslStrFormatIntStringInt64(int i, const std::string& s,
637 int64_t i64) { // NOLINT
638 return absl::StrFormat("%d %s %d", i, s, i64);
639 }
640
CodegenAbslStrAppendFormatInt(std::string * out,int i)641 void CodegenAbslStrAppendFormatInt(std::string* out, int i) { // NOLINT
642 absl::StrAppendFormat(out, "%d", i);
643 }
644
CodegenAbslStrAppendFormatIntStringInt64(std::string * out,int i,const std::string & s,int64_t i64)645 void CodegenAbslStrAppendFormatIntStringInt64(std::string* out, int i,
646 const std::string& s,
647 int64_t i64) { // NOLINT
648 absl::StrAppendFormat(out, "%d %s %d", i, s, i64);
649 }
650