abseil-cpp/absl/strings/substitute_test.cc
Go to the documentation of this file.
1 // Copyright 2017 The Abseil Authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include "absl/strings/substitute.h"
16 
17 #include <cstdint>
18 #include <vector>
19 
20 #include "gtest/gtest.h"
21 #include "absl/strings/str_cat.h"
22 
23 namespace {
24 
25 TEST(SubstituteTest, Substitute) {
26  // Basic.
27  EXPECT_EQ("Hello, world!", absl::Substitute("$0, $1!", "Hello", "world"));
28 
29  // Non-char* types.
30  EXPECT_EQ("123 0.2 0.1 foo true false x",
31  absl::Substitute("$0 $1 $2 $3 $4 $5 $6", 123, 0.2, 0.1f,
32  std::string("foo"), true, false, 'x'));
33 
34  // All int types.
35  EXPECT_EQ(
36  "-32767 65535 "
37  "-1234567890 3234567890 "
38  "-1234567890 3234567890 "
39  "-1234567890123456789 9234567890123456789",
40  absl::Substitute(
41  "$0 $1 $2 $3 $4 $5 $6 $7",
42  static_cast<short>(-32767), // NOLINT(runtime/int)
43  static_cast<unsigned short>(65535), // NOLINT(runtime/int)
44  -1234567890, 3234567890U, -1234567890L, 3234567890UL,
45  -int64_t{1234567890123456789}, uint64_t{9234567890123456789u}));
46 
47  // Hex format
48  EXPECT_EQ("0 1 f ffff0ffff 0123456789abcdef",
49  absl::Substitute("$0$1$2$3$4 $5", //
50  absl::Hex(0), absl::Hex(1, absl::kSpacePad2),
51  absl::Hex(0xf, absl::kSpacePad2),
52  absl::Hex(int16_t{-1}, absl::kSpacePad5),
53  absl::Hex(int16_t{-1}, absl::kZeroPad5),
54  absl::Hex(0x123456789abcdef, absl::kZeroPad16)));
55 
56  // Dec format
57  EXPECT_EQ("0 115 -1-0001 81985529216486895",
58  absl::Substitute("$0$1$2$3$4 $5", //
59  absl::Dec(0), absl::Dec(1, absl::kSpacePad2),
60  absl::Dec(0xf, absl::kSpacePad2),
61  absl::Dec(int16_t{-1}, absl::kSpacePad5),
62  absl::Dec(int16_t{-1}, absl::kZeroPad5),
63  absl::Dec(0x123456789abcdef, absl::kZeroPad16)));
64 
65  // Pointer.
66  const int* int_p = reinterpret_cast<const int*>(0x12345);
67  std::string str = absl::Substitute("$0", int_p);
68  EXPECT_EQ(absl::StrCat("0x", absl::Hex(int_p)), str);
69 
70  // Volatile Pointer.
71  // Like C++ streamed I/O, such pointers implicitly become bool
72  volatile int vol = 237;
73  volatile int *volatile volptr = &vol;
74  str = absl::Substitute("$0", volptr);
75  EXPECT_EQ("true", str);
76 
77  // null is special. StrCat prints 0x0. Substitute prints NULL.
78  const uint64_t* null_p = nullptr;
79  str = absl::Substitute("$0", null_p);
80  EXPECT_EQ("NULL", str);
81 
82  // char* is also special.
83  const char* char_p = "print me";
84  str = absl::Substitute("$0", char_p);
85  EXPECT_EQ("print me", str);
86 
87  char char_buf[16];
88  strncpy(char_buf, "print me too", sizeof(char_buf));
89  str = absl::Substitute("$0", char_buf);
90  EXPECT_EQ("print me too", str);
91 
92  // null char* is "doubly" special. Represented as the empty string.
93  char_p = nullptr;
94  str = absl::Substitute("$0", char_p);
95  EXPECT_EQ("", str);
96 
97  // Out-of-order.
98  EXPECT_EQ("b, a, c, b", absl::Substitute("$1, $0, $2, $1", "a", "b", "c"));
99 
100  // Literal $
101  EXPECT_EQ("$", absl::Substitute("$$"));
102 
103  EXPECT_EQ("$1", absl::Substitute("$$1"));
104 
105  // Test all overloads.
106  EXPECT_EQ("a", absl::Substitute("$0", "a"));
107  EXPECT_EQ("a b", absl::Substitute("$0 $1", "a", "b"));
108  EXPECT_EQ("a b c", absl::Substitute("$0 $1 $2", "a", "b", "c"));
109  EXPECT_EQ("a b c d", absl::Substitute("$0 $1 $2 $3", "a", "b", "c", "d"));
110  EXPECT_EQ("a b c d e",
111  absl::Substitute("$0 $1 $2 $3 $4", "a", "b", "c", "d", "e"));
112  EXPECT_EQ("a b c d e f", absl::Substitute("$0 $1 $2 $3 $4 $5", "a", "b", "c",
113  "d", "e", "f"));
114  EXPECT_EQ("a b c d e f g", absl::Substitute("$0 $1 $2 $3 $4 $5 $6", "a", "b",
115  "c", "d", "e", "f", "g"));
116  EXPECT_EQ("a b c d e f g h",
117  absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7", "a", "b", "c", "d", "e",
118  "f", "g", "h"));
119  EXPECT_EQ("a b c d e f g h i",
120  absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8", "a", "b", "c", "d",
121  "e", "f", "g", "h", "i"));
122  EXPECT_EQ("a b c d e f g h i j",
123  absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8 $9", "a", "b", "c",
124  "d", "e", "f", "g", "h", "i", "j"));
125  EXPECT_EQ("a b c d e f g h i j b0",
126  absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10", "a", "b", "c",
127  "d", "e", "f", "g", "h", "i", "j"));
128 
129  const char* null_cstring = nullptr;
130  EXPECT_EQ("Text: ''", absl::Substitute("Text: '$0'", null_cstring));
131 }
132 
133 TEST(SubstituteTest, SubstituteAndAppend) {
134  std::string str = "Hello";
135  absl::SubstituteAndAppend(&str, ", $0!", "world");
136  EXPECT_EQ("Hello, world!", str);
137 
138  // Test all overloads.
139  str.clear();
140  absl::SubstituteAndAppend(&str, "$0", "a");
141  EXPECT_EQ("a", str);
142  str.clear();
143  absl::SubstituteAndAppend(&str, "$0 $1", "a", "b");
144  EXPECT_EQ("a b", str);
145  str.clear();
146  absl::SubstituteAndAppend(&str, "$0 $1 $2", "a", "b", "c");
147  EXPECT_EQ("a b c", str);
148  str.clear();
149  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3", "a", "b", "c", "d");
150  EXPECT_EQ("a b c d", str);
151  str.clear();
152  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4", "a", "b", "c", "d", "e");
153  EXPECT_EQ("a b c d e", str);
154  str.clear();
155  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5", "a", "b", "c", "d", "e",
156  "f");
157  EXPECT_EQ("a b c d e f", str);
158  str.clear();
159  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6", "a", "b", "c", "d",
160  "e", "f", "g");
161  EXPECT_EQ("a b c d e f g", str);
162  str.clear();
163  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7", "a", "b", "c", "d",
164  "e", "f", "g", "h");
165  EXPECT_EQ("a b c d e f g h", str);
166  str.clear();
167  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7 $8", "a", "b", "c",
168  "d", "e", "f", "g", "h", "i");
169  EXPECT_EQ("a b c d e f g h i", str);
170  str.clear();
171  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7 $8 $9", "a", "b",
172  "c", "d", "e", "f", "g", "h", "i", "j");
173  EXPECT_EQ("a b c d e f g h i j", str);
174 }
175 
176 TEST(SubstituteTest, VectorBoolRef) {
177  std::vector<bool> v = {true, false};
178  const auto& cv = v;
179  EXPECT_EQ("true false true false",
180  absl::Substitute("$0 $1 $2 $3", v[0], v[1], cv[0], cv[1]));
181 
182  std::string str = "Logic be like: ";
183  absl::SubstituteAndAppend(&str, "$0 $1 $2 $3", v[0], v[1], cv[0], cv[1]);
184  EXPECT_EQ("Logic be like: true false true false", str);
185 }
186 
187 TEST(SubstituteTest, Enums) {
188  enum UnscopedEnum { kEnum0 = 0, kEnum1 = 1 };
189  EXPECT_EQ("0 1", absl::Substitute("$0 $1", UnscopedEnum::kEnum0,
190  UnscopedEnum::kEnum1));
191 
192  enum class ScopedEnum { kEnum0 = 0, kEnum1 = 1 };
193  EXPECT_EQ("0 1",
194  absl::Substitute("$0 $1", ScopedEnum::kEnum0, ScopedEnum::kEnum1));
195 
196  enum class ScopedEnumInt32 : int32_t { kEnum0 = 989, kEnum1 = INT32_MIN };
197  EXPECT_EQ("989 -2147483648",
198  absl::Substitute("$0 $1", ScopedEnumInt32::kEnum0,
199  ScopedEnumInt32::kEnum1));
200 
201  enum class ScopedEnumUInt32 : uint32_t { kEnum0 = 1, kEnum1 = UINT32_MAX };
202  EXPECT_EQ("1 4294967295", absl::Substitute("$0 $1", ScopedEnumUInt32::kEnum0,
203  ScopedEnumUInt32::kEnum1));
204 
205  enum class ScopedEnumInt64 : int64_t { kEnum0 = -1, kEnum1 = 42949672950 };
206  EXPECT_EQ("-1 42949672950", absl::Substitute("$0 $1", ScopedEnumInt64::kEnum0,
207  ScopedEnumInt64::kEnum1));
208 
209  enum class ScopedEnumUInt64 : uint64_t { kEnum0 = 1, kEnum1 = 42949672950 };
210  EXPECT_EQ("1 42949672950", absl::Substitute("$0 $1", ScopedEnumUInt64::kEnum0,
211  ScopedEnumUInt64::kEnum1));
212 
213  enum class ScopedEnumChar : signed char { kEnum0 = -1, kEnum1 = 1 };
214  EXPECT_EQ("-1 1", absl::Substitute("$0 $1", ScopedEnumChar::kEnum0,
215  ScopedEnumChar::kEnum1));
216 
217  enum class ScopedEnumUChar : unsigned char {
218  kEnum0 = 0,
219  kEnum1 = 1,
220  kEnumMax = 255
221  };
222  EXPECT_EQ("0 1 255", absl::Substitute("$0 $1 $2", ScopedEnumUChar::kEnum0,
223  ScopedEnumUChar::kEnum1,
224  ScopedEnumUChar::kEnumMax));
225 
226  enum class ScopedEnumInt16 : int16_t { kEnum0 = -100, kEnum1 = 10000 };
227  EXPECT_EQ("-100 10000", absl::Substitute("$0 $1", ScopedEnumInt16::kEnum0,
228  ScopedEnumInt16::kEnum1));
229 
230  enum class ScopedEnumUInt16 : uint16_t { kEnum0 = 0, kEnum1 = 10000 };
231  EXPECT_EQ("0 10000", absl::Substitute("$0 $1", ScopedEnumUInt16::kEnum0,
232  ScopedEnumUInt16::kEnum1));
233 }
234 
235 #ifdef GTEST_HAS_DEATH_TEST
236 
237 TEST(SubstituteDeathTest, SubstituteDeath) {
238  EXPECT_DEBUG_DEATH(
239  static_cast<void>(absl::Substitute(absl::string_view("-$2"), "a", "b")),
240  "Invalid absl::Substitute\\(\\) format string: asked for \"\\$2\", "
241  "but only 2 args were given.");
242  EXPECT_DEBUG_DEATH(
243  static_cast<void>(absl::Substitute(absl::string_view("-$z-"))),
244  "Invalid absl::Substitute\\(\\) format string: \"-\\$z-\"");
245  EXPECT_DEBUG_DEATH(
246  static_cast<void>(absl::Substitute(absl::string_view("-$"))),
247  "Invalid absl::Substitute\\(\\) format string: \"-\\$\"");
248 }
249 
250 #endif // GTEST_HAS_DEATH_TEST
251 
252 } // namespace
xds_interop_client.str
str
Definition: xds_interop_client.py:487
absl::StrCat
std::string StrCat(const AlphaNum &a, const AlphaNum &b)
Definition: abseil-cpp/absl/strings/str_cat.cc:98
uint16_t
unsigned short uint16_t
Definition: stdint-msvc2008.h:79
absl::string_view
Definition: abseil-cpp/absl/strings/string_view.h:167
testing::internal::string
::std::string string
Definition: bloaty/third_party/protobuf/third_party/googletest/googletest/include/gtest/internal/gtest-port.h:881
UINT32_MAX
#define UINT32_MAX
Definition: stdint-msvc2008.h:142
u
OPENSSL_EXPORT pem_password_cb void * u
Definition: pem.h:351
absl::kZeroPad16
@ kZeroPad16
Definition: abseil-cpp/absl/strings/str_cat.h:101
EXPECT_EQ
#define EXPECT_EQ(a, b)
Definition: iomgr/time_averaged_stats_test.cc:27
uint32_t
unsigned int uint32_t
Definition: stdint-msvc2008.h:80
absl::Hex
Definition: abseil-cpp/absl/strings/str_cat.h:134
autogen_x86imm.f
f
Definition: autogen_x86imm.py:9
int16_t
signed short int16_t
Definition: stdint-msvc2008.h:76
int64_t
signed __int64 int64_t
Definition: stdint-msvc2008.h:89
TEST
#define TEST(name, init_size,...)
Definition: arena_test.cc:75
setup.v
v
Definition: third_party/bloaty/third_party/capstone/bindings/python/setup.py:42
uint64_t
unsigned __int64 uint64_t
Definition: stdint-msvc2008.h:90
absl::kZeroPad5
@ kZeroPad5
Definition: abseil-cpp/absl/strings/str_cat.h:90
absl::kSpacePad5
@ kSpacePad5
Definition: abseil-cpp/absl/strings/str_cat.h:110
absl::kSpacePad2
@ kSpacePad2
Definition: abseil-cpp/absl/strings/str_cat.h:107
INT32_MIN
#define INT32_MIN
Definition: stdint-msvc2008.h:136
cv
unsigned cv
Definition: cxa_demangle.cpp:4908
L
lua_State * L
Definition: upb/upb/bindings/lua/main.c:35
absl::Substitute
ABSL_MUST_USE_RESULT std::string Substitute(absl::string_view format)
Definition: abseil-cpp/absl/strings/substitute.h:506
absl::Dec
Definition: abseil-cpp/absl/strings/str_cat.h:184
int32_t
signed int int32_t
Definition: stdint-msvc2008.h:77
absl::SubstituteAndAppend
void SubstituteAndAppend(std::string *output, absl::string_view format)
Definition: abseil-cpp/absl/strings/substitute.h:248

grpc
Author(s):
autogenerated on Fri May 16 2025 03:00:24