Mercurial > hg > CbC > CbC_llvm

comparison unittests/Support/FormatVariadicTest.cpp @ 148:63bd29f05246

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merged
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Wed, 14 Aug 2019 19:46:37 +0900
parents c2174574ed3a
children
comparison
equal deleted inserted replaced
146:3fc4d5c3e21e 148:63bd29f05246
1 //===- FormatVariadicTest.cpp - Unit tests for string formatting ----------===// 1 //===- FormatVariadicTest.cpp - Unit tests for string formatting ----------===//
2 // 2 //
3 // The LLVM Compiler Infrastructure 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // 4 // See https://llvm.org/LICENSE.txt for license information.
5 // This file is distributed under the University of Illinois Open Source 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 // License. See LICENSE.TXT for details.
7 // 6 //
8 //===----------------------------------------------------------------------===// 7 //===----------------------------------------------------------------------===//
9 8
10 #include "llvm/Support/FormatVariadic.h" 9 #include "llvm/Support/FormatVariadic.h"
10 #include "llvm/Support/Error.h"
11 #include "llvm/Support/FormatAdapters.h" 11 #include "llvm/Support/FormatAdapters.h"
12 #include "gtest/gtest.h" 12 #include "gtest/gtest.h"
13 13
14 using namespace llvm; 14 using namespace llvm;
15 15
141 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type); 141 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
142 EXPECT_EQ(0u, Replacements[0].Index); 142 EXPECT_EQ(0u, Replacements[0].Index);
143 EXPECT_EQ(0u, Replacements[0].Align); 143 EXPECT_EQ(0u, Replacements[0].Align);
144 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where); 144 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
145 EXPECT_EQ("0:1", Replacements[0].Options); 145 EXPECT_EQ("0:1", Replacements[0].Options);
146
147 // 9. Custom padding character
148 Replacements = formatv_object_base::parseFormatString("{0,p+4:foo}");
149 ASSERT_EQ(1u, Replacements.size());
150 EXPECT_EQ("0,p+4:foo", Replacements[0].Spec);
151 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
152 EXPECT_EQ(0u, Replacements[0].Index);
153 EXPECT_EQ(4u, Replacements[0].Align);
154 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
155 EXPECT_EQ('p', Replacements[0].Pad);
156 EXPECT_EQ("foo", Replacements[0].Options);
157
158 // Format string special characters are allowed as padding character
159 Replacements = formatv_object_base::parseFormatString("{0,-+4:foo}");
160 ASSERT_EQ(1u, Replacements.size());
161 EXPECT_EQ("0,-+4:foo", Replacements[0].Spec);
162 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
163 EXPECT_EQ(0u, Replacements[0].Index);
164 EXPECT_EQ(4u, Replacements[0].Align);
165 EXPECT_EQ(AlignStyle::Right, Replacements[0].Where);
166 EXPECT_EQ('-', Replacements[0].Pad);
167 EXPECT_EQ("foo", Replacements[0].Options);
168
169 Replacements = formatv_object_base::parseFormatString("{0,+-4:foo}");
170 ASSERT_EQ(1u, Replacements.size());
171 EXPECT_EQ("0,+-4:foo", Replacements[0].Spec);
172 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
173 EXPECT_EQ(0u, Replacements[0].Index);
174 EXPECT_EQ(4u, Replacements[0].Align);
175 EXPECT_EQ(AlignStyle::Left, Replacements[0].Where);
176 EXPECT_EQ('+', Replacements[0].Pad);
177 EXPECT_EQ("foo", Replacements[0].Options);
178
179 Replacements = formatv_object_base::parseFormatString("{0,==4:foo}");
180 ASSERT_EQ(1u, Replacements.size());
181 EXPECT_EQ("0,==4:foo", Replacements[0].Spec);
182 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
183 EXPECT_EQ(0u, Replacements[0].Index);
184 EXPECT_EQ(4u, Replacements[0].Align);
185 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);
186 EXPECT_EQ('=', Replacements[0].Pad);
187 EXPECT_EQ("foo", Replacements[0].Options);
188
189 Replacements = formatv_object_base::parseFormatString("{0,:=4:foo}");
190 ASSERT_EQ(1u, Replacements.size());
191 EXPECT_EQ("0,:=4:foo", Replacements[0].Spec);
192 EXPECT_EQ(ReplacementType::Format, Replacements[0].Type);
193 EXPECT_EQ(0u, Replacements[0].Index);
194 EXPECT_EQ(4u, Replacements[0].Align);
195 EXPECT_EQ(AlignStyle::Center, Replacements[0].Where);
196 EXPECT_EQ(':', Replacements[0].Pad);
197 EXPECT_EQ("foo", Replacements[0].Options);
146 } 198 }
147 199
148 TEST(FormatVariadicTest, DefaultReplacementValues) { 200 TEST(FormatVariadicTest, DefaultReplacementValues) {
149 // 2. If options string is missing, it defaults to empty. 201 // 2. If options string is missing, it defaults to empty.
150 auto Replacements = formatv_object_base::parseFormatString("{0,3}"); 202 auto Replacements = formatv_object_base::parseFormatString("{0,3}");
417 // 2. With padding and precision. 469 // 2. With padding and precision.
418 EXPECT_EQ(" 0.000", formatv("{0,8:F3}", 0.0).str()); 470 EXPECT_EQ(" 0.000", formatv("{0,8:F3}", 0.0).str());
419 EXPECT_EQ(" -1.100", formatv("{0,8:F3}", -1.1).str()); 471 EXPECT_EQ(" -1.100", formatv("{0,8:F3}", -1.1).str());
420 EXPECT_EQ("1234.568", formatv("{0,8:F3}", 1234.5678).str()); 472 EXPECT_EQ("1234.568", formatv("{0,8:F3}", 1234.5678).str());
421 EXPECT_EQ(" -0.001", formatv("{0,8:F3}", -.0012345678).str()); 473 EXPECT_EQ(" -0.001", formatv("{0,8:F3}", -.0012345678).str());
474 }
475
476 TEST(FormatVariadicTest, CustomPaddingCharacter) {
477 // 1. Padding with custom character
478 EXPECT_EQ("==123", formatv("{0,=+5}", 123).str());
479 EXPECT_EQ("=123=", formatv("{0,==5}", 123).str());
480 EXPECT_EQ("123==", formatv("{0,=-5}", 123).str());
481
482 // 2. Combined with zero padding
483 EXPECT_EQ("=00123=", formatv("{0,==7:5}", 123).str());
422 } 484 }
423 485
424 struct format_tuple { 486 struct format_tuple {
425 const char *Fmt; 487 const char *Fmt;
426 explicit format_tuple(const char *Fmt) : Fmt(Fmt) {} 488 explicit format_tuple(const char *Fmt) : Fmt(Fmt) {}
607 EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str()); 669 EXPECT_EQ("0C 3M", formatv("{0}", std::move(R)).str());
608 EXPECT_EQ("0C 3M", formatv("{0}", Recorder()).str()); 670 EXPECT_EQ("0C 3M", formatv("{0}", Recorder()).str());
609 EXPECT_EQ(0, R.Copied); 671 EXPECT_EQ(0, R.Copied);
610 EXPECT_EQ(0, R.Moved); 672 EXPECT_EQ(0, R.Moved);
611 } 673 }
674
675 namespace adl {
676 struct X {};
677 raw_ostream &operator<<(raw_ostream &OS, const X &) { return OS << "X"; }
678 } // namespace adl
679 TEST(FormatVariadicTest, FormatStreamable) {
680 adl::X X;
681 EXPECT_EQ("X", formatv("{0}", X).str());
682 }
683
684 TEST(FormatVariadicTest, FormatError) {
685 auto E1 = make_error<StringError>("X", inconvertibleErrorCode());
686 EXPECT_EQ("X", formatv("{0}", E1).str());
687 EXPECT_TRUE(E1.isA<StringError>()); // not consumed
688 EXPECT_EQ("X", formatv("{0}", fmt_consume(std::move(E1))).str());
689 EXPECT_FALSE(E1.isA<StringError>()); // consumed
690 }