Blender  V3.3
BLI_string_ref_test.cc
Go to the documentation of this file.
1 /* SPDX-License-Identifier: Apache-2.0 */
2 
3 #include "BLI_strict_flags.h"
4 #include "BLI_string_ref.hh"
5 #include "BLI_vector.hh"
6 #include "testing/testing.h"
7 
8 namespace blender::tests {
9 
10 TEST(string_ref_null, DefaultConstructor)
11 {
12  StringRefNull ref;
13  EXPECT_EQ(ref.size(), 0);
14  EXPECT_EQ(ref[0], '\0');
15 }
16 
17 TEST(string_ref_null, CStringConstructor)
18 {
19  const char *str = "Hello";
20  StringRefNull ref(str);
21  EXPECT_EQ(ref.size(), 5);
22  EXPECT_EQ(ref.data(), str);
23 }
24 
25 TEST(string_ref_null, CStringLengthConstructor)
26 {
27  const char *str = "Hello";
28  StringRefNull ref(str, 5);
29  EXPECT_EQ(ref.size(), 5);
30  EXPECT_EQ(ref.data(), str);
31 }
32 
33 TEST(string_ref, DefaultConstructor)
34 {
35  StringRef ref;
36  EXPECT_EQ(ref.size(), 0);
37 }
38 
39 TEST(string_ref, StartEndConstructor)
40 {
41  const char *text = "hello world";
42  StringRef ref(text, text + 5);
43  EXPECT_EQ(ref.size(), 5);
44  EXPECT_TRUE(ref == "hello");
45  EXPECT_FALSE(ref == "hello ");
46 }
47 
48 TEST(string_ref, StartEndConstructorNullptr)
49 {
50  StringRef ref(nullptr, nullptr);
51  EXPECT_EQ(ref.size(), 0);
52  EXPECT_TRUE(ref == "");
53 }
54 
55 TEST(string_ref, StartEndConstructorSame)
56 {
57  const char *text = "hello world";
58  StringRef ref(text, text);
59  EXPECT_EQ(ref.size(), 0);
60  EXPECT_TRUE(ref == "");
61 }
62 
63 TEST(string_ref, CStringConstructor)
64 {
65  const char *str = "Test";
66  StringRef ref(str);
67  EXPECT_EQ(ref.size(), 4);
68  EXPECT_EQ(ref.data(), str);
69 }
70 
71 TEST(string_ref, PointerWithLengthConstructor)
72 {
73  const char *str = "Test";
74  StringRef ref(str, 2);
75  EXPECT_EQ(ref.size(), 2);
76  EXPECT_EQ(ref.data(), str);
77 }
78 
79 TEST(string_ref, StdStringConstructor)
80 {
81  std::string str = "Test";
82  StringRef ref(str);
83  EXPECT_EQ(ref.size(), 4);
84  EXPECT_EQ(ref.data(), str.data());
85 }
86 
87 TEST(string_ref, SubscriptOperator)
88 {
89  StringRef ref("hello");
90  EXPECT_EQ(ref.size(), 5);
91  EXPECT_EQ(ref[0], 'h');
92  EXPECT_EQ(ref[1], 'e');
93  EXPECT_EQ(ref[2], 'l');
94  EXPECT_EQ(ref[3], 'l');
95  EXPECT_EQ(ref[4], 'o');
96 }
97 
98 TEST(string_ref, ToStdString)
99 {
100  StringRef ref("test");
101  std::string str = ref;
102  EXPECT_EQ(str.size(), 4);
103  EXPECT_EQ(str, "test");
104 }
105 
106 TEST(string_ref, Print)
107 {
108  StringRef ref("test");
109  std::stringstream ss;
110  ss << ref;
111  ss << ref;
112  std::string str = ss.str();
113  EXPECT_EQ(str.size(), 8);
114  EXPECT_EQ(str, "testtest");
115 }
116 
117 TEST(string_ref, Add)
118 {
119  StringRef a("qwe");
120  StringRef b("asd");
121  std::string result = a + b;
122  EXPECT_EQ(result, "qweasd");
123 }
124 
125 TEST(string_ref, AddCharPtr1)
126 {
127  StringRef ref("test");
128  std::string result = ref + "qwe";
129  EXPECT_EQ(result, "testqwe");
130 }
131 
132 TEST(string_ref, AddCharPtr2)
133 {
134  StringRef ref("test");
135  std::string result = "qwe" + ref;
136  EXPECT_EQ(result, "qwetest");
137 }
138 
139 TEST(string_ref, AddString1)
140 {
141  StringRef ref("test");
142  std::string result = ref + std::string("asd");
143  EXPECT_EQ(result, "testasd");
144 }
145 
146 TEST(string_ref, AddString2)
147 {
148  StringRef ref("test");
149  std::string result = std::string("asd") + ref;
150  EXPECT_EQ(result, "asdtest");
151 }
152 
153 TEST(string_ref, CompareEqual)
154 {
155  StringRef ref1("test");
156  StringRef ref2("test");
157  StringRef ref3("other");
158  EXPECT_TRUE(ref1 == ref2);
159  EXPECT_FALSE(ref1 == ref3);
160  EXPECT_TRUE(ref1 != ref3);
161  EXPECT_FALSE(ref1 != ref2);
162 }
163 
164 TEST(string_ref, CompareEqualCharPtr1)
165 {
166  StringRef ref("test");
167  EXPECT_TRUE(ref == "test");
168  EXPECT_FALSE(ref == "other");
169  EXPECT_TRUE(ref != "other");
170  EXPECT_FALSE(ref != "test");
171 }
172 
173 TEST(string_ref, CompareEqualCharPtr2)
174 {
175  StringRef ref("test");
176  EXPECT_TRUE("test" == ref);
177  EXPECT_FALSE("other" == ref);
178  EXPECT_TRUE(ref != "other");
179  EXPECT_FALSE(ref != "test");
180 }
181 
182 TEST(string_ref, CompareEqualString1)
183 {
184  StringRef ref("test");
185  EXPECT_TRUE(ref == std::string("test"));
186  EXPECT_FALSE(ref == std::string("other"));
187  EXPECT_TRUE(ref != std::string("other"));
188  EXPECT_FALSE(ref != std::string("test"));
189 }
190 
191 TEST(string_ref, CompareEqualString2)
192 {
193  StringRef ref("test");
194  EXPECT_TRUE(std::string("test") == ref);
195  EXPECT_FALSE(std::string("other") == ref);
196  EXPECT_TRUE(std::string("other") != ref);
197  EXPECT_FALSE(std::string("test") != ref);
198 }
199 
200 TEST(string_ref, Iterate)
201 {
202  StringRef ref("test");
203  Vector<char> chars;
204  for (char c : ref) {
205  chars.append(c);
206  }
207  EXPECT_EQ(chars.size(), 4);
208  EXPECT_EQ(chars[0], 't');
209  EXPECT_EQ(chars[1], 'e');
210  EXPECT_EQ(chars[2], 's');
211  EXPECT_EQ(chars[3], 't');
212 }
213 
214 TEST(string_ref, StartsWith)
215 {
216  StringRef ref("test");
217  EXPECT_TRUE(ref.startswith(""));
218  EXPECT_TRUE(ref.startswith("t"));
219  EXPECT_TRUE(ref.startswith("te"));
220  EXPECT_TRUE(ref.startswith("tes"));
221  EXPECT_TRUE(ref.startswith("test"));
222  EXPECT_FALSE(ref.startswith("test "));
223  EXPECT_FALSE(ref.startswith("a"));
224 }
225 
226 TEST(string_ref, EndsWith)
227 {
228  StringRef ref("test");
229  EXPECT_TRUE(ref.endswith(""));
230  EXPECT_TRUE(ref.endswith("t"));
231  EXPECT_TRUE(ref.endswith("st"));
232  EXPECT_TRUE(ref.endswith("est"));
233  EXPECT_TRUE(ref.endswith("test"));
234  EXPECT_FALSE(ref.endswith(" test"));
235  EXPECT_FALSE(ref.endswith("a"));
236 }
237 
238 TEST(string_ref, DropPrefixN)
239 {
240  StringRef ref("test");
241  StringRef ref2 = ref.drop_prefix(2);
242  StringRef ref3 = ref2.drop_prefix(2);
243  EXPECT_EQ(ref2.size(), 2);
244  EXPECT_EQ(ref3.size(), 0);
245  EXPECT_EQ(ref2, "st");
246  EXPECT_EQ(ref3, "");
247 }
248 
249 TEST(string_ref, DropPrefixLargeN)
250 {
251  StringRef ref("test");
252  StringRef ref2 = ref.drop_prefix(100);
253  EXPECT_EQ(ref2.size(), 0);
254  EXPECT_EQ(ref2, "");
255 }
256 
257 TEST(string_ref, DropKnownPrefix)
258 {
259  StringRef ref("test");
260  StringRef ref2 = ref.drop_known_prefix("tes");
261  EXPECT_EQ(ref2.size(), 1);
262  EXPECT_EQ(ref2, "t");
263 }
264 
265 TEST(string_ref, DropSuffix)
266 {
267  StringRef ref("test");
268  StringRef ref2 = ref.drop_suffix(1);
269  EXPECT_EQ(ref2.size(), 3);
270  EXPECT_EQ(ref2, "tes");
271 }
272 
273 TEST(string_ref, DropSuffixLargeN)
274 {
275  StringRef ref("test");
276  StringRef ref2 = ref.drop_suffix(100);
277  EXPECT_EQ(ref2.size(), 0);
278  EXPECT_EQ(ref2, "");
279 }
280 
281 TEST(string_ref, TrimArbitrary)
282 {
283  StringRef ref1("test");
284  StringRef ref2(" test ");
285  StringRef ref3(" \t Urož with spaces ");
286  StringRef ref4("žžžžleepyžžž");
287  EXPECT_EQ(ref1.trim("t"), "es");
288  EXPECT_EQ(ref1.trim("te"), "s");
289  EXPECT_EQ(ref1.trim("test"), "");
290  EXPECT_EQ(ref2.trim("t"), " test ");
291  EXPECT_EQ(ref2.trim(""), " test ");
292  EXPECT_EQ(ref3.trim(" "), "\t Urož with spaces"); /* TAB should be kept. */
293  EXPECT_EQ(ref4.trim("ž"), "leepy");
294 }
295 
296 TEST(string_ref, TrimWhitespace)
297 {
298  StringRef ref1("test");
299  StringRef ref2(" test ");
300  StringRef ref3(" \t Urož with spaces ");
301  StringRef ref4(" \t \n\r \t ");
302  EXPECT_EQ(ref1.trim(), "test");
303  EXPECT_EQ(ref2.trim(), "test");
304  EXPECT_EQ(ref3.trim(), "Urož with spaces");
305  EXPECT_EQ(ref4.trim(), "");
306 }
307 
308 TEST(string_ref, TrimCharacter)
309 {
310  StringRef ref1("test");
311  StringRef ref2(" test ");
312  StringRef ref3("does this work?");
313  EXPECT_EQ(ref1.trim('t'), "es");
314  EXPECT_EQ(ref1.trim('p'), "test");
315  EXPECT_EQ(ref2.trim(' '), "test");
316  EXPECT_EQ(ref3.trim('\000'), "does this work?");
317 }
318 
319 TEST(string_ref, Substr)
320 {
321  StringRef ref("hello world");
322  EXPECT_EQ(ref.substr(0, 5), "hello");
323  EXPECT_EQ(ref.substr(4, 0), "");
324  EXPECT_EQ(ref.substr(3, 4), "lo w");
325  EXPECT_EQ(ref.substr(6, 5), "world");
326  EXPECT_EQ(ref.substr(8), "rld");
327  EXPECT_EQ(ref.substr(8, 100), "rld");
328 }
329 
330 TEST(string_ref, Copy)
331 {
332  StringRef ref("hello");
333  char dst[10];
334  memset(dst, 0xFF, 10);
335  ref.copy(dst);
336  EXPECT_EQ(dst[5], '\0');
337  EXPECT_EQ(dst[6], 0xFF);
338  EXPECT_EQ(ref, dst);
339 }
340 
341 TEST(string_ref, FromStringView)
342 {
343  std::string_view view = "hello";
344  StringRef ref = view;
345  EXPECT_EQ(ref, "hello");
346 }
347 
348 TEST(string_ref, ToStringView)
349 {
350  StringRef ref = "hello";
351  std::string_view view = ref;
352  EXPECT_EQ(view, "hello");
353 }
354 
355 TEST(string_ref, Constexpr)
356 {
357  constexpr StringRef sref("World");
358  BLI_STATIC_ASSERT(sref[2] == 'r', "");
359  BLI_STATIC_ASSERT(sref.size() == 5, "");
360  std::array<int, static_cast<std::size_t>(sref.find_first_of('o'))> compiles = {1};
361  EXPECT_EQ(compiles[0], 1);
362 }
363 } // namespace blender::tests
#define BLI_STATIC_ASSERT(a, msg)
Definition: BLI_assert.h:83
EXPECT_EQ(BLI_expr_pylike_eval(expr, nullptr, 0, &result), EXPR_PYLIKE_INVALID)
Strict compiler flags for areas of code we want to ensure don't do conversions without us knowing abo...
static AppView * view
static btMatrix3x3 Add(const btMatrix3x3 &a, const btMatrix3x3 &b)
void copy(char *dst, int64_t dst_size) const
constexpr StringRef substr(int64_t start, int64_t size) const
constexpr bool startswith(StringRef prefix) const
constexpr bool endswith(StringRef suffix) const
constexpr int64_t size() const
constexpr StringRef trim() const
constexpr const char * data() const
constexpr StringRef drop_prefix(int64_t n) const
constexpr StringRef drop_suffix(int64_t n) const
constexpr StringRef drop_known_prefix(StringRef prefix) const
int64_t size() const
Definition: BLI_vector.hh:694
void append(const T &value)
Definition: BLI_vector.hh:433
#define str(s)
static unsigned c
Definition: RandGen.cpp:83
static unsigned a[3]
Definition: RandGen.cpp:78
TEST(any, DefaultConstructor)
Definition: BLI_any_test.cc:10
static const pxr::TfToken b("b", pxr::TfToken::Immortal)