1 //===-- StringListTest.cpp ------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Utility/StringList.h"
10 #include "lldb/Utility/StreamString.h"
11 #include "gmock/gmock.h"
12 #include "gtest/gtest.h"
13 
14 using namespace lldb_private;
15 
16 TEST(StringListTest, DefaultConstructor) {
17   StringList s;
18   EXPECT_EQ(0U, s.GetSize());
19 }
20 
21 TEST(StringListTest, Assignment) {
22   StringList orig;
23   orig.AppendString("foo");
24   orig.AppendString("bar");
25 
26   StringList s = orig;
27 
28   ASSERT_EQ(2U, s.GetSize());
29   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
30   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
31 
32   ASSERT_EQ(2U, orig.GetSize());
33   EXPECT_STREQ("foo", orig.GetStringAtIndex(0));
34   EXPECT_STREQ("bar", orig.GetStringAtIndex(1));
35 }
36 
37 TEST(StringListTest, AppendStringStdString) {
38   StringList s;
39   s.AppendString("foo");
40   ASSERT_EQ(1U, s.GetSize());
41   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
42 
43   s.AppendString("bar");
44   ASSERT_EQ(2U, s.GetSize());
45   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
46   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
47 }
48 
49 TEST(StringListTest, AppendStringCString) {
50   StringList s;
51   s.AppendString("foo", strlen("foo"));
52   ASSERT_EQ(1U, s.GetSize());
53   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
54 
55   s.AppendString("bar", strlen("bar"));
56   ASSERT_EQ(2U, s.GetSize());
57   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
58   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
59 }
60 
61 TEST(StringListTest, AppendStringMove) {
62   StringList s;
63   std::string foo = "foo";
64   std::string bar = "bar";
65 
66   s.AppendString(std::move(foo));
67   ASSERT_EQ(1U, s.GetSize());
68   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
69 
70   s.AppendString(std::move(bar));
71   ASSERT_EQ(2U, s.GetSize());
72   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
73   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
74 }
75 
76 TEST(StringListTest, ShiftStdString) {
77   StringList s;
78   std::string foo = "foo";
79   std::string bar = "bar";
80 
81   s << foo;
82   ASSERT_EQ(1U, s.GetSize());
83   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
84 
85   s << bar;
86   ASSERT_EQ(2U, s.GetSize());
87   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
88   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
89 }
90 
91 TEST(StringListTest, ShiftCString) {
92   StringList s;
93   s << "foo";
94   ASSERT_EQ(1U, s.GetSize());
95   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
96 
97   s << "bar";
98   ASSERT_EQ(2U, s.GetSize());
99   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
100   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
101 }
102 
103 TEST(StringListTest, ShiftMove) {
104   StringList s;
105   std::string foo = "foo";
106   std::string bar = "bar";
107 
108   s << std::move(foo);
109   ASSERT_EQ(1U, s.GetSize());
110   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
111 
112   s << std::move(bar);
113   ASSERT_EQ(2U, s.GetSize());
114   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
115   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
116 }
117 
118 TEST(StringListTest, AppendListCStringArrayEmpty) {
119   StringList s;
120   s.AppendList(nullptr, 0);
121   EXPECT_EQ(0U, s.GetSize());
122 }
123 
124 TEST(StringListTest, AppendListCStringArray) {
125   StringList s;
126   const char *items[3] = {"foo", "", "bar"};
127   s.AppendList(items, 3);
128 
129   EXPECT_EQ(3U, s.GetSize());
130   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
131   EXPECT_STREQ("", s.GetStringAtIndex(1));
132   EXPECT_STREQ("bar", s.GetStringAtIndex(2));
133 }
134 
135 TEST(StringListTest, AppendList) {
136   StringList other;
137   other.AppendString("foo");
138   other.AppendString("");
139   other.AppendString("bar");
140 
141   StringList empty;
142 
143   StringList s;
144   s.AppendList(other);
145 
146   EXPECT_EQ(3U, s.GetSize());
147   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
148   EXPECT_STREQ("", s.GetStringAtIndex(1));
149   EXPECT_STREQ("bar", s.GetStringAtIndex(2));
150 
151   EXPECT_EQ(3U, other.GetSize());
152   EXPECT_STREQ("foo", other.GetStringAtIndex(0));
153   EXPECT_STREQ("", other.GetStringAtIndex(1));
154   EXPECT_STREQ("bar", other.GetStringAtIndex(2));
155 
156   s.AppendList(empty);
157   s.AppendList(other);
158   EXPECT_EQ(6U, s.GetSize());
159   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
160   EXPECT_STREQ("", s.GetStringAtIndex(1));
161   EXPECT_STREQ("bar", s.GetStringAtIndex(2));
162   EXPECT_STREQ("foo", s.GetStringAtIndex(3));
163   EXPECT_STREQ("", s.GetStringAtIndex(4));
164   EXPECT_STREQ("bar", s.GetStringAtIndex(5));
165 
166   EXPECT_EQ(3U, other.GetSize());
167   EXPECT_STREQ("foo", other.GetStringAtIndex(0));
168   EXPECT_STREQ("", other.GetStringAtIndex(1));
169   EXPECT_STREQ("bar", other.GetStringAtIndex(2));
170 }
171 
172 TEST(StringListTest, GetSize) {
173   StringList s;
174   s.AppendString("foo");
175   EXPECT_EQ(1U, s.GetSize());
176 
177   s.AppendString("foo");
178   EXPECT_EQ(2U, s.GetSize());
179 
180   s.AppendString("foobar");
181   EXPECT_EQ(3U, s.GetSize());
182 }
183 
184 TEST(StringListTest, SetSize) {
185   StringList s;
186   s.SetSize(3);
187   EXPECT_EQ(3U, s.GetSize());
188   EXPECT_STREQ("", s.GetStringAtIndex(0));
189   EXPECT_STREQ("", s.GetStringAtIndex(1));
190   EXPECT_STREQ("", s.GetStringAtIndex(2));
191 }
192 
193 TEST(StringListTest, SplitIntoLines) {
194   StringList s;
195   s.SplitIntoLines("\nfoo\nbar\n\n");
196   EXPECT_EQ(4U, s.GetSize());
197   EXPECT_STREQ("", s.GetStringAtIndex(0));
198   EXPECT_STREQ("foo", s.GetStringAtIndex(1));
199   EXPECT_STREQ("bar", s.GetStringAtIndex(2));
200   EXPECT_STREQ("", s.GetStringAtIndex(3));
201 }
202 
203 TEST(StringListTest, SplitIntoLinesSingleTrailingCR) {
204   StringList s;
205   s.SplitIntoLines("\r");
206   EXPECT_EQ(1U, s.GetSize());
207   EXPECT_STREQ("", s.GetStringAtIndex(0));
208 }
209 
210 TEST(StringListTest, SplitIntoLinesEmpty) {
211   StringList s;
212   s.SplitIntoLines("");
213   EXPECT_EQ(0U, s.GetSize());
214 }
215 
216 TEST(StringListTest, LongestCommonPrefixEmpty) {
217   StringList s;
218   std::string prefix = s.LongestCommonPrefix();
219   EXPECT_EQ("", prefix);
220 }
221 
222 TEST(StringListTest, LongestCommonPrefix) {
223   StringList s;
224   s.AppendString("foo");
225   s.AppendString("foobar");
226   s.AppendString("foo");
227   s.AppendString("foozar");
228 
229   std::string prefix = s.LongestCommonPrefix();
230   EXPECT_EQ("foo", prefix);
231 }
232 
233 TEST(StringListTest, LongestCommonPrefixSingleElement) {
234   StringList s;
235   s.AppendString("foo");
236 
237   std::string prefix = s.LongestCommonPrefix();
238   EXPECT_EQ("foo", prefix);
239 }
240 
241 TEST(StringListTest, LongestCommonPrefixDuplicateElement) {
242   StringList s;
243   s.AppendString("foo");
244   s.AppendString("foo");
245 
246   std::string prefix = s.LongestCommonPrefix();
247   EXPECT_EQ("foo", prefix);
248 }
249 
250 TEST(StringListTest, LongestCommonPrefixNoPrefix) {
251   StringList s;
252   s.AppendString("foo");
253   s.AppendString("1foobar");
254   s.AppendString("2foo");
255   s.AppendString("3foozar");
256 
257   std::string prefix = s.LongestCommonPrefix();
258   EXPECT_EQ("", prefix);
259 }
260 
261 TEST(StringListTest, Clear) {
262   StringList s;
263   s.Clear();
264   EXPECT_EQ(0U, s.GetSize());
265 
266   s.AppendString("foo");
267   s.Clear();
268   EXPECT_EQ(0U, s.GetSize());
269 
270   s.AppendString("foo");
271   s.AppendString("foo");
272   s.Clear();
273   EXPECT_EQ(0U, s.GetSize());
274 }
275 
276 TEST(StringListTest, PopBack) {
277   StringList s;
278   s.AppendString("foo");
279   s.AppendString("bar");
280   s.AppendString("boo");
281 
282   s.PopBack();
283   EXPECT_EQ(2U, s.GetSize());
284   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
285   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
286 
287   s.PopBack();
288   EXPECT_EQ(1U, s.GetSize());
289   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
290 
291   s.PopBack();
292   EXPECT_EQ(0U, s.GetSize());
293 }
294 
295 TEST(StringListTest, RemoveBlankLines) {
296   StringList s;
297 
298   // Nothing to remove yet.
299   s.RemoveBlankLines();
300   EXPECT_EQ(0U, s.GetSize());
301 
302   // Add some lines.
303   s.AppendString("");
304   s.AppendString("");
305   s.AppendString("\t");
306   s.AppendString("");
307   s.AppendString(" ");
308   s.AppendString("");
309   s.AppendString("");
310   s.AppendString("f");
311   s.AppendString("");
312   s.AppendString("");
313 
314   // And remove all the empty ones again.
315   s.RemoveBlankLines();
316 
317   EXPECT_EQ(3U, s.GetSize());
318   EXPECT_STREQ("\t", s.GetStringAtIndex(0));
319   EXPECT_STREQ(" ", s.GetStringAtIndex(1));
320   EXPECT_STREQ("f", s.GetStringAtIndex(2));
321 }
322 
323 TEST(StringListTest, InsertStringAtIndexStart) {
324   StringList s;
325 
326   s.InsertStringAtIndex(0, "bar");
327   EXPECT_EQ(1U, s.GetSize());
328   EXPECT_STREQ("bar", s.GetStringAtIndex(0));
329 
330   s.InsertStringAtIndex(0, "foo");
331   EXPECT_EQ(2U, s.GetSize());
332   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
333   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
334 }
335 
336 TEST(StringListTest, InsertStringAtIndexEnd) {
337   StringList s;
338 
339   s.InsertStringAtIndex(0, "foo");
340   EXPECT_EQ(1U, s.GetSize());
341   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
342 
343   s.InsertStringAtIndex(1, "bar");
344   EXPECT_EQ(2U, s.GetSize());
345   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
346   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
347 }
348 
349 TEST(StringListTest, InsertStringAtIndexOutOfBounds) {
350   StringList s;
351 
352   s.InsertStringAtIndex(1, "foo");
353   EXPECT_EQ(1U, s.GetSize());
354   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
355 
356   // FIXME: Inserting at an OOB index will always just append to the list. This
357   // seems not very intuitive.
358   s.InsertStringAtIndex(3, "bar");
359   EXPECT_EQ(2U, s.GetSize());
360   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
361   EXPECT_STREQ("bar", s.GetStringAtIndex(1));
362 }
363 
364 TEST(StringListTest, InsertStringAtIndexStdString) {
365   StringList s;
366 
367   std::string foo = "foo";
368   s.InsertStringAtIndex(0, foo);
369   EXPECT_EQ(1U, s.GetSize());
370   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
371 }
372 
373 TEST(StringListTest, InsertStringAtIndexMove) {
374   StringList s;
375 
376   std::string foo = "foo";
377   s.InsertStringAtIndex(0, std::move(foo));
378   EXPECT_EQ(1U, s.GetSize());
379   EXPECT_STREQ("foo", s.GetStringAtIndex(0));
380 }
381 
382 TEST(StringListTest, CopyListEmpty) {
383   StringList s;
384 
385   EXPECT_EQ("", s.CopyList());
386   EXPECT_EQ("", s.CopyList("+"));
387 }
388 
389 TEST(StringListTest, CopyListSingle) {
390   StringList s;
391   s.AppendString("ab");
392 
393   EXPECT_EQ("ab", s.CopyList());
394   EXPECT_EQ("-ab", s.CopyList("-"));
395 }
396 
397 TEST(StringListTest, CopyList) {
398   StringList s;
399   s.AppendString("ab");
400   s.AppendString("cd");
401 
402   EXPECT_EQ("ab\ncd", s.CopyList());
403   EXPECT_EQ("-ab\n-cd", s.CopyList("-"));
404 }
405 
406 TEST(StringListTest, Join) {
407   StringList s;
408   s.AppendString("ab");
409   s.AppendString("cd");
410 
411   StreamString ss;
412   s.Join(" ", ss);
413 
414   EXPECT_EQ("ab cd", ss.GetString());
415 }
416 
417 TEST(StringListTest, JoinEmpty) {
418   StringList s;
419 
420   StreamString ss;
421   s.Join(" ", ss);
422 
423   EXPECT_EQ("", ss.GetString());
424 }
425 
426 TEST(StringListTest, JoinSingle) {
427   StringList s;
428   s.AppendString("foo");
429 
430   StreamString ss;
431   s.Join(" ", ss);
432 
433   EXPECT_EQ("foo", ss.GetString());
434 }
435 
436 TEST(StringListTest, JoinThree) {
437   StringList s;
438   s.AppendString("1");
439   s.AppendString("2");
440   s.AppendString("3");
441 
442   StreamString ss;
443   s.Join(" ", ss);
444 
445   EXPECT_EQ("1 2 3", ss.GetString());
446 }
447 
448 TEST(StringListTest, JoinNonSpace) {
449   StringList s;
450   s.AppendString("1");
451   s.AppendString("2");
452   s.AppendString("3");
453 
454   StreamString ss;
455   s.Join(".", ss);
456 
457   EXPECT_EQ("1.2.3", ss.GetString());
458 }
459 
460 TEST(StringListTest, JoinMultiCharSeparator) {
461   StringList s;
462   s.AppendString("1");
463   s.AppendString("2");
464   s.AppendString("3");
465 
466   StreamString ss;
467   s.Join("--", ss);
468 
469   EXPECT_EQ("1--2--3", ss.GetString());
470 }
471 
472 TEST(StringListTest, GetMaxStringLengthEqualSize) {
473   StringList s;
474   s.AppendString("123");
475   s.AppendString("123");
476   EXPECT_EQ(3U, s.GetMaxStringLength());
477 }
478 
479 TEST(StringListTest, GetMaxStringLengthIncreasingSize) {
480   StringList s;
481   s.AppendString("123");
482   s.AppendString("1234");
483   EXPECT_EQ(4U, s.GetMaxStringLength());
484 }
485 
486 TEST(StringListTest, GetMaxStringLengthDecreasingSize) {
487   StringList s;
488   s.AppendString("1234");
489   s.AppendString("123");
490   EXPECT_EQ(4U, s.GetMaxStringLength());
491 }
492 
493 TEST(StringListTest, GetMaxStringLengthMixed) {
494   StringList s;
495   s.AppendString("123");
496   s.AppendString("1");
497   s.AppendString("123");
498   s.AppendString("1234");
499   s.AppendString("123");
500   s.AppendString("1");
501   EXPECT_EQ(4U, s.GetMaxStringLength());
502 }
503 
504 TEST(StringListTest, GetMaxStringLengthEmpty) {
505   StringList s;
506   EXPECT_EQ(0U, s.GetMaxStringLength());
507 }
508 
509 TEST(StringListTest, ForRangeEmpty) {
510   StringList s;
511   for (const std::string &e : s)
512     FAIL() << "Shouldn't have hit an element in for range" << e;
513 }
514 
515 TEST(StringListTest, ForRange) {
516   StringList s;
517   s.AppendString("a");
518   s.AppendString("b");
519   s.AppendString("c");
520   std::vector<std::string> recorded;
521   for (const std::string &e : s)
522     recorded.push_back(e);
523   EXPECT_THAT(recorded, testing::ElementsAre("a", "b", "c"));
524 }
525